Merge pull request #2700 from ethereum/release/1.4

Geth 1.4.7 "Colourise"

.gitignore

@@ -23,11 +23,17 @@ Godeps/_workspace/bin
 .project
 .settings
 
+deploy/osx/Mist.app
+deploy/osx/Mist\ Installer.dmg
+cmd/mist/assets/ext/ethereum.js/
+
 # used by the Makefile
 /build/_workspace/
 /build/bin/
-/geth*.zip
 
 # travis
 profile.tmp
 profile.cov
+
+# vagrant
+.vagrant

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "cmd/mist/assets/ext/ethereum.js"]
+	path = cmd/mist/assets/ext/ethereum.js
+	url = https://github.com/ethereum/web3.js

.travis.yml

@@ -1,45 +1,31 @@
 language: go
-go_import_path: github.com/ethereum/go-ethereum
-sudo: false
-matrix:
-  include:
-    - os: linux
-      dist: trusty
-      go: 1.4.2
-    - os: linux
-      dist: trusty
-      go: 1.5.4
-    - os: linux
-      dist: trusty
-      go: 1.6.2
-    - os: osx
-      go: 1.6.2
-
-    # This builder does the PPA upload (and nothing else).
-    - os: linux
-      dist: trusty
-      go: 1.6.2
-      env: PPA
-      addons:
-        apt:
-          packages:
-            - devscripts
-            - debhelper
-            - dput
-      script:
-        - go run build/ci.go debsrc -signer "Felix Lange (Geth CI Testing Key) <fjl@twurst.com>" -upload ppa:lp-fjl/geth-ci-testing
-
+go:
+  - 1.4.2
+  - 1.5.4
+  - 1.6.2
 install:
+  # - go get code.google.com/p/go.tools/cmd/goimports
+  # - go get github.com/golang/lint/golint
+  # - go get golang.org/x/tools/cmd/vet
   - go get golang.org/x/tools/cmd/cover
+before_script:
+  # - gofmt -l -w .
+  # - goimports -l -w .
+  # - golint .
+  # - go vet ./...
+  # - go test -race ./...
 script:
-  - go run build/ci.go install
-  - go run build/ci.go test -coverage -vet
+  - make travis-test-with-coverage
 after_success:
-  # - go run build/ci.go archive -type tar
-
+  - bash <(curl -s https://codecov.io/bash)
+env:
+  global:
+    - secure: "U2U1AmkU4NJBgKR/uUAebQY87cNL0+1JHjnLOmmXwxYYyj5ralWb1aSuSH3qSXiT93qLBmtaUkuv9fberHVqrbAeVlztVdUsKAq7JMQH+M99iFkC9UiRMqHmtjWJ0ok4COD1sRYixxi21wb/JrMe3M1iL4QJVS61iltjHhVdM64="
+sudo: false
 notifications:
   webhooks:
     urls:
       - https://webhooks.gitter.im/e/e09ccdce1048c5e03445
     on_success: change
     on_failure: always
+    on_start: false

Godeps/Godeps.json

@@ -20,8 +20,8 @@
 		},
 		{
 			"ImportPath": "github.com/ethereum/ethash",
-			"Comment": "v23.1-247-g2e80de5",
-			"Rev": "2e80de5022370cfe632195b1720db52d07ff8a77"
+			"Comment": "v23.1-245-g25b32de",
+			"Rev": "25b32de0c0271065c28c3719c2bfe86959d72f0c"
 		},
 		{
 			"ImportPath": "github.com/fatih/color",
@@ -117,7 +117,7 @@
 		},
 		{
 			"ImportPath": "github.com/rjeczalik/notify",
-			"Rev": "f627deca7a510d96f0ef9388f2d0e8b16d21f87f"
+			"Rev": "5dd6205716539662f8f14ab513552b41eab69d5d"
 		},
 		{
 			"ImportPath": "github.com/robertkrimen/otto",

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/endian.h

@@ -19,7 +19,7 @@
   # define BYTE_ORDER    LITTLE_ENDIAN
 #elif defined( __QNXNTO__ ) && defined( __BIGENDIAN__ )
   # define BIG_ENDIAN 1234
-  # define BYTE_ORDER BIG_ENDIAN
+  # define BYTE_ORDER    BIG_ENDIAN
 #else
 # include <endian.h>
 #endif
@@ -59,20 +59,21 @@
 
 #define fix_endian32(dst_, src_) dst_ = ethash_swap_u32(src_)
 #define fix_endian32_same(val_) val_ = ethash_swap_u32(val_)
-#define fix_endian64(dst_, src_) dst_ = ethash_swap_u64(src_)
+#define fix_endian64(dst_, src_) dst_ = ethash_swap_u64(src_
 #define fix_endian64_same(val_) val_ = ethash_swap_u64(val_)
-#define fix_endian_arr32(arr_, size_) \
-  do { \
-    for (unsigned i_ = 0; i_ < (size_); ++i_) { \
-      arr_[i_] = ethash_swap_u32(arr_[i_]); \
-    } \
-  } while (0)
-#define fix_endian_arr64(arr_, size_) \
-  do { \
-    for (unsigned i_ = 0; i_ < (size_); ++i_) { \
-      arr_[i_] = ethash_swap_u64(arr_[i_]); \
-    } \
-  } while (0)
+#define fix_endian_arr32(arr_, size_)			\
+	do {										\
+	for (unsigned i_ = 0; i_ < (size_), ++i_) { \
+		arr_[i_] = ethash_swap_u32(arr_[i_]);	\
+	}											\
+	while (0)
+#define fix_endian_arr64(arr_, size_)			\
+	do {										\
+	for (unsigned i_ = 0; i_ < (size_), ++i_) { \
+		arr_[i_] = ethash_swap_u64(arr_[i_]);	\
+	}											\
+	while (0)									\
+
 #else
 # error "endian not supported"
 #endif // BYTE_ORDER

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/internal.c

@@ -257,7 +257,7 @@ static bool ethash_hash(
 void ethash_quick_hash(
 	ethash_h256_t* return_hash,
 	ethash_h256_t const* header_hash,
-	uint64_t nonce,
+	uint64_t const nonce,
 	ethash_h256_t const* mix_hash
 )
 {

Godeps/_workspace/src/github.com/rjeczalik/notify/.travis.yml

@@ -21,9 +21,10 @@ env:
    - PATH=$HOME/bin:$PATH
 
 install:
+ - go get golang.org/x/tools/cmd/vet
  - go get -t -v ./...
 
 script:
- - "(go version | grep -q 1.4) || go tool vet -all ."
+ - go tool vet -all .
  - go install $GOFLAGS ./...
  - go test -v -race $GOFLAGS ./...

Godeps/_workspace/src/github.com/rjeczalik/notify/appveyor.yml

@@ -11,6 +11,7 @@ environment:
 
 install:
  - go version
+ - go get golang.org/x/tools/cmd/vet
  - go get -v -t ./...
 
 build_script:

Godeps/_workspace/src/github.com/rjeczalik/notify/watcher_fsevents.go

@@ -133,7 +133,7 @@ func (w *watch) Dispatch(ev []FSEvent) {
 			ev[i].Flags, ev[i].Path, i, ev[i].ID, len(ev))
 		if ev[i].Flags&failure != 0 {
 			// TODO(rjeczalik): missing error handling
-			continue
+			panic("unhandled error: " + Event(ev[i].Flags).String())
 		}
 		if !strings.HasPrefix(ev[i].Path, w.path) {
 			continue

Makefile

@@ -2,8 +2,8 @@
 # with Go source code. If you know what GOPATH is then you probably
 # don't need to bother with make.
 
-.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 geth-cross evm all test travis-test-with-coverage xgo clean
+.PHONY: geth-linux geth-linux-386 geth-linux-amd64
 .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
@@ -13,41 +13,25 @@ GOBIN = build/bin
 GO ?= latest
 
 geth:
-	build/env.sh go run build/ci.go install ./cmd/geth
+	build/env.sh go build -i -v $(shell build/flags.sh) -o $(GOBIN)/geth ./cmd/geth
 	@echo "Done building."
 	@echo "Run \"$(GOBIN)/geth\" to launch geth."
 
-evm:
-	build/env.sh go run build/ci.go install ./cmd/evm
-	@echo "Done building."
-	@echo "Run \"$(GOBIN)/evm to start the evm."
-
-all:
-	build/env.sh go run build/ci.go install
-
-test: all
-	build/env.sh go run build/ci.go test
-
-clean:
-	rm -fr build/_workspace/pkg/ Godeps/_workspace/pkg $(GOBIN)/*
-
-# Cross Compilation Targets (xgo)
-
 geth-cross: geth-linux geth-darwin geth-windows geth-android geth-ios
 	@echo "Full cross compilation done:"
 	@ls -ld $(GOBIN)/geth-*
 
-geth-linux: geth-linux-386 geth-linux-amd64 geth-linux-arm geth-linux-mips64 geth-linux-mips64le
+geth-linux: geth-linux-386 geth-linux-amd64 geth-linux-arm
 	@echo "Linux cross compilation done:"
 	@ls -ld $(GOBIN)/geth-linux-*
 
-geth-linux-386:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --dest=$(GOBIN) --targets=linux/386 -v ./cmd/geth
+geth-linux-386: xgo
+	build/env.sh $(GOBIN)/xgo --go=$(GO) --dest=$(GOBIN) --targets=linux/386 -v $(shell build/flags.sh) ./cmd/geth
 	@echo "Linux 386 cross compilation done:"
 	@ls -ld $(GOBIN)/geth-linux-* | grep 386
 
-geth-linux-amd64:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --dest=$(GOBIN) --targets=linux/amd64 -v ./cmd/geth
+geth-linux-amd64: xgo
+	build/env.sh $(GOBIN)/xgo --go=$(GO) --dest=$(GOBIN) --targets=linux/amd64 -v $(shell build/flags.sh) ./cmd/geth
 	@echo "Linux amd64 cross compilation done:"
 	@ls -ld $(GOBIN)/geth-linux-* | grep amd64
 
@@ -55,47 +39,37 @@ geth-linux-arm: geth-linux-arm-5 geth-linux-arm-6 geth-linux-arm-7 geth-linux-ar
 	@echo "Linux ARM cross compilation done:"
 	@ls -ld $(GOBIN)/geth-linux-* | grep arm
 
-geth-linux-arm-5:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --dest=$(GOBIN) --targets=linux/arm-5 -v ./cmd/geth
+geth-linux-arm-5: xgo
+	build/env.sh $(GOBIN)/xgo --go=$(GO) --dest=$(GOBIN) --targets=linux/arm-5 -v $(shell build/flags.sh) ./cmd/geth
 	@echo "Linux ARMv5 cross compilation done:"
 	@ls -ld $(GOBIN)/geth-linux-* | grep arm-5
 
-geth-linux-arm-6:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --dest=$(GOBIN) --targets=linux/arm-6 -v ./cmd/geth
+geth-linux-arm-6: xgo
+	build/env.sh $(GOBIN)/xgo --go=$(GO) --dest=$(GOBIN) --targets=linux/arm-6 -v $(shell build/flags.sh) ./cmd/geth
 	@echo "Linux ARMv6 cross compilation done:"
 	@ls -ld $(GOBIN)/geth-linux-* | grep arm-6
 
-geth-linux-arm-7:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --dest=$(GOBIN) --targets=linux/arm-7 -v ./cmd/geth
+geth-linux-arm-7: xgo
+	build/env.sh $(GOBIN)/xgo --go=$(GO) --dest=$(GOBIN) --targets=linux/arm-7 -v $(shell build/flags.sh) ./cmd/geth
 	@echo "Linux ARMv7 cross compilation done:"
 	@ls -ld $(GOBIN)/geth-linux-* | grep arm-7
 
-geth-linux-arm64:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --dest=$(GOBIN) --targets=linux/arm64 -v ./cmd/geth
+geth-linux-arm64: xgo
+	build/env.sh $(GOBIN)/xgo --go=$(GO) --dest=$(GOBIN) --targets=linux/arm64 -v $(shell build/flags.sh) ./cmd/geth
 	@echo "Linux ARM64 cross compilation done:"
 	@ls -ld $(GOBIN)/geth-linux-* | grep arm64
 
-geth-linux-mips64:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --dest=$(GOBIN) --targets=linux/mips64 -v ./cmd/geth
-	@echo "Linux MIPS64 cross compilation done:"
-	@ls -ld $(GOBIN)/geth-linux-* | grep mips64
-
-geth-linux-mips64le:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --dest=$(GOBIN) --targets=linux/mips64le -v ./cmd/geth
-	@echo "Linux MIPS64le cross compilation done:"
-	@ls -ld $(GOBIN)/geth-linux-* | grep mips64le
-
 geth-darwin: geth-darwin-386 geth-darwin-amd64
 	@echo "Darwin cross compilation done:"
 	@ls -ld $(GOBIN)/geth-darwin-*
 
-geth-darwin-386:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --dest=$(GOBIN) --targets=darwin/386 -v ./cmd/geth
+geth-darwin-386: xgo
+	build/env.sh $(GOBIN)/xgo --go=$(GO) --dest=$(GOBIN) --targets=darwin/386 -v $(shell build/flags.sh) ./cmd/geth
 	@echo "Darwin 386 cross compilation done:"
 	@ls -ld $(GOBIN)/geth-darwin-* | grep 386
 
-geth-darwin-amd64:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --dest=$(GOBIN) --targets=darwin/amd64 -v ./cmd/geth
+geth-darwin-amd64: xgo
+	build/env.sh $(GOBIN)/xgo --go=$(GO) --dest=$(GOBIN) --targets=darwin/amd64 -v $(shell build/flags.sh) ./cmd/geth
 	@echo "Darwin amd64 cross compilation done:"
 	@ls -ld $(GOBIN)/geth-darwin-* | grep amd64
 
@@ -103,22 +77,45 @@ geth-windows: geth-windows-386 geth-windows-amd64
 	@echo "Windows cross compilation done:"
 	@ls -ld $(GOBIN)/geth-windows-*
 
-geth-windows-386:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --dest=$(GOBIN) --targets=windows/386 -v ./cmd/geth
+geth-windows-386: xgo
+	build/env.sh $(GOBIN)/xgo --go=$(GO) --dest=$(GOBIN) --targets=windows/386 -v $(shell build/flags.sh) ./cmd/geth
 	@echo "Windows 386 cross compilation done:"
 	@ls -ld $(GOBIN)/geth-windows-* | grep 386
 
-geth-windows-amd64:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --dest=$(GOBIN) --targets=windows/amd64 -v ./cmd/geth
+geth-windows-amd64: xgo
+	build/env.sh $(GOBIN)/xgo --go=$(GO) --dest=$(GOBIN) --targets=windows/amd64 -v $(shell build/flags.sh) ./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
+geth-android: xgo
+	build/env.sh $(GOBIN)/xgo --go=$(GO) --dest=$(GOBIN) --targets=android-21/aar -v $(shell build/flags.sh) ./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
+geth-ios: xgo
+	build/env.sh $(GOBIN)/xgo --go=$(GO) --dest=$(GOBIN) --targets=ios-7.0/framework -v $(shell build/flags.sh) ./cmd/geth
 	@echo "iOS framework cross compilation done:"
 	@ls -ld $(GOBIN)/geth-ios-*
+
+evm:
+	build/env.sh $(GOROOT)/bin/go install -v $(shell build/flags.sh) ./cmd/evm
+	@echo "Done building."
+	@echo "Run \"$(GOBIN)/evm to start the evm."
+
+all:
+	for cmd in `ls ./cmd/`; do \
+		 build/env.sh go build -i -v $(shell build/flags.sh) -o $(GOBIN)/$$cmd ./cmd/$$cmd; \
+	done
+
+test: all
+	build/env.sh go test ./...
+
+travis-test-with-coverage: all
+	build/env.sh go vet ./...
+	build/env.sh build/test-global-coverage.sh
+
+xgo:
+	build/env.sh go get github.com/karalabe/xgo
+
+clean:
+	rm -fr build/_workspace/pkg/ Godeps/_workspace/pkg $(GOBIN)/*

README.md

@@ -54,197 +54,6 @@ The go-ethereum project comes with several wrappers/executables found in the `cm
 | `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`). |
 
-## Running geth
-
-Going through all the possible command line flags is out of scope here (please consult our
-[CLI Wiki page](https://github.com/ethereum/go-ethereum/wiki/Command-Line-Options)), but we've
-enumerated a few common parameter combos to get you up to speed quickly on how you can run your
-own Geth instance.
-
-### Full node on the main Ethereum network
-
-By far the most common scenario is people wanting to simply interact with the Ethereum network:
-create accounts; transfer funds; deploy and interact with contracts. For this particular use-case
-the user doesn't care about years-old historical data, so we can fast-sync quickly to the current
-state of the network. To do so:
-
-```
-$ geth --fast --cache=512 console
-```
-
-This command will:
-
- * Start geth in fast sync mode (`--fast`), causing it to download more data in exchange for avoiding
-   processing the entire history of the Ethereum network, which is very CPU intensive.
- * Bump the memory allowance of the database to 512MB (`--cache=512`), which can help significantly in
-   sync times especially for HDD users. This flag is optional and you can set it as high or as low as
-   you'd like, though we'd recommend the 512MB - 2GB range.
- * Start up Geth's built-in interactive [JavaScript console](https://github.com/ethereum/go-ethereum/wiki/JavaScript-Console),
-   (via the trailing `console` subcommand) through which you can invoke all official [`web3` methods](https://github.com/ethereum/wiki/wiki/JavaScript-API)
-   as well as Geth's own [management APIs](https://github.com/ethereum/go-ethereum/wiki/Management-APIs).
-   This too is optional and if you leave it out you can always attach to an already running Geth instance
-   with `geth --attach`.
-
-### Full node on the Ethereum test network
-
-Transitioning towards developers, if you'd like to play around with creating Ethereum contracts, you
-almost certainly would like to do that without any real money involved until you get the hang of the
-entire system. In other words, instead of attaching to the main network, you want to join the **test**
-network with your node, which is fully equivalent to the main network, but with play-Ether only.
-
-```
-$ geth --testnet --fast --cache=512 console
-```
-
-The `--fast`, `--cache` flags and `console` subcommand have the exact same meaning as above and they
-are equially useful on the testnet too. Please see above for their explanations if you've skipped to
-here.
-
-Specifying the `--testnet` flag however will reconfigure your Geth instance a bit:
-
- * Instead of using the default data directory (`~/.ethereum` on Linux for example), Geth will nest
-   itself one level deeper into a `testnet` subfolder (`~/.ethereum/testnet` on Linux).
- * Instead of connecting the main Ethereum network, the client will connect to the test network,
-   which uses different P2P bootnodes, different network IDs and genesis states.
-
-*Note: Although there are some internal protective measures to prevent transactions from crossing
-over between the main network and test network (different starting nonces), you should make sure to
-always use separate accounts for play-money and real-money. Unless you manually move accounts, Geth
-will by default correctly separate the two networks and will not make any accounts available between
-them.*
-
-### Programatically interfacing Geth nodes
-
-As a developer, sooner rather than later you'll want to start interacting with Geth and the Ethereum
-network via your own programs and not manually through the console. To aid this, Geth has built in
-support for a JSON-RPC based APIs ([standard APIs](https://github.com/ethereum/wiki/wiki/JSON-RPC) and
-[Geth specific APIs](https://github.com/ethereum/go-ethereum/wiki/Management-APIs)). These can be
-exposed via HTTP, WebSockets and IPC (unix sockets on unix based platroms, and named pipes on Windows).
-
-The IPC interface is enabled by default and exposes all the APIs supported by Geth, whereas the HTTP
-and WS interfaces need to manually be enabled and only expose a subset of APIs due to security reasons.
-These can be turned on/off and configured as you'd expect.
-
-HTTP based JSON-RPC API options:
-
-  * `--rpc` Enable the HTTP-RPC server
-  * `--rpcaddr` HTTP-RPC server listening interface (default: "localhost")
-  * `--rpcport` HTTP-RPC server listening port (default: 8545)
-  * `--rpcapi` API's offered over the HTTP-RPC interface (default: "eth,net,web3")
-  * `--rpccorsdomain` Comma separated list of domains from which to accept cross origin requests (browser enforced)
-  * `--ws` Enable the WS-RPC server
-  * `--wsaddr` WS-RPC server listening interface (default: "localhost")
-  * `--wsport` WS-RPC server listening port (default: 8546)
-  * `--wsapi` API's offered over the WS-RPC interface (default: "eth,net,web3")
-  * `--wsorigins` Origins from which to accept websockets requests
-  * `--ipcdisable` Disable the IPC-RPC server
-  * `--ipcapi` API's offered over the IPC-RPC interface (default: "admin,debug,eth,miner,net,personal,shh,txpool,web3")
-  * `--ipcpath` Filename for IPC socket/pipe within the datadir (explicit paths escape it)
-
-You'll need to use your own programming environments' capabilities (libraries, tools, etc) to connect
-via HTTP, WS or IPC to a Geth node configured with the above flags and you'll need to speak [JSON-RPC](http://www.jsonrpc.org/specification)
-on all transports. You can reuse the same connection for multiple requests!
-
-**Note: Please understand the security implications of opening up an HTTP/WS based transport before
-doing so! Hackers on the internet are actively trying to subvert Ethereum nodes with exposed APIs!
-Further, all browser tabs can access locally running webservers, so malicious webpages could try to
-subvert locally available APIs!**
-
-### Operating a private network
-
-Maintaining your own private network is more involved as a lot of configurations taken for granted in
-the official networks need to be manually set up.
-
-#### Defining the private genesis state
-
-First, you'll need to create the genesis state of your networks, which all nodes need to be aware of
-and agree upon. This consists of a small JSON file (e.g. call it `genesis.json`):
-
-```json
-{
-  "alloc"      : {},
-  "coinbase"   : "0x0000000000000000000000000000000000000000",
-  "difficulty" : "0x20000",
-  "extraData"  : "",
-  "gasLimit"   : "0x2fefd8",
-  "nonce"      : "0x0000000000000042",
-  "mixhash"    : "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "timestamp"  : "0x00"
-}
-```
-
-The above fields should be fine for most purposes, although we'd recommend changing the `nonce` to
-some random value so you prevent unknown remote nodes from being able to connect to you. If you'd
-like to pre-fund some accounts for easier testing, you can populate the `alloc` field with account
-configs:
-
-```json
-"alloc": {
-  "0x0000000000000000000000000000000000000001": {"balance": "111111111"},
-  "0x0000000000000000000000000000000000000002": {"balance": "222222222"}
-}
-```
-
-With the genesis state defined in the above JSON file, you'll need to initialize **every** Geth node
-with it prior to starting it up to ensure all blockchain parameters are correctly set:
-
-```
-$ geth init path/to/genesis.json
-```
-
-#### Creating the rendezvous point
-
-With all nodes that you want to run initialized to the desired genesis state, you'll need to start a
-bootstrap node that others can use to find each other in your network and/or over the internet. The
-clean way is to configure and run a dedicated bootnode:
-
-```
-$ bootnode --genkey=boot.key
-$ bootnode --nodekey=boot.key
-```
-
-With the bootnode online, it will display an [`enode` URL](https://github.com/ethereum/wiki/wiki/enode-url-format)
-that other nodes can use to connect to it and exchange peer information. Make sure to replace the
-displayed IP address information (most probably `[::]`) with your externally accessible IP to get the
-actual `enode` URL.
-
-*Note: You could also use a full fledged Geth node as a bootnode, but it's the less recommended way.*
-
-#### Starting up your member nodes
-
-With the bootnode operational and externally reachable (you can try `telnet <ip> <port>` to ensure
-it's indeed reachable), start every subsequent Geth node pointed to the bootnode for peer discovery
-via the `--bootnodes` flag. It will probably also be desirable to keep the data directory of your
-private network separated, so do also specify a custom `--datadir` flag.
-
-```
-$ geth --datadir=path/to/custom/data/folder --bootnodes=<bootnode-enode-url-from-above>
-```
-
-*Note: Since your network will be completely cut off from the main and test networks, you'll also
-need to configure a miner to process transactions and create new blocks for you.*
-
-#### Running a private miner
-
-Mining on the public Ethereum network is a complex task as it's only feasible using GPUs, requiring
-an OpenCL or CUDA enabled `ethminer` instance. For information on such a setup, please consult the
-[EtherMining subreddit](https://www.reddit.com/r/EtherMining/) and the [Genoil miner](https://github.com/Genoil/cpp-ethereum)
-repository.
-
-In a private network setting however, a single CPU miner instance is more than enough for practical
-purposes as it can produce a stable stream of blocks at the correct intervals without needing heavy
-resources (consider running on a single thread, no need for multiple ones either). To start a Geth
-instance for mining, run it with all your usual flags, extended by:
-
-```
-$ geth <usual-flags> --mine --minerthreads=1 --etherbase=0x0000000000000000000000000000000000000000
-```
-
-Which will start mining bocks and transactions on a single CPU thread, crediting all proceedings to
-the account specified by `--etherbase`. You can further tune the mining by changing the default gas
-limit blocks converge to (`--targetgaslimit`) and the price transactions are accepted at (`--gasprice`).
-
 ## Contribution
 
 Thank you for considering to help out with the source code! We welcome contributions from
@@ -277,3 +86,5 @@ included in our repository in the `COPYING.LESSER` file.
 The go-ethereum binaries (i.e. all code inside of the `cmd` directory) is licensed under the
 [GNU General Public License v3.0](http://www.gnu.org/licenses/gpl-3.0.en.html), also included
 in our repository in the `COPYING` file.
+
+

VERSION

@@ -1 +1 @@
-1.4.19
+1.4.7

accounts/abi/bind/backends/simulated.go

@@ -27,11 +27,10 @@ import (
 	"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"
 )
 
 // Default chain configuration which sets homestead phase at block 0 (i.e. no frontier)
-var chainConfig = &params.ChainConfig{ChainId: new(big.Int), HomesteadBlock: big.NewInt(0), EIP150Block: new(big.Int), EIP158Block: new(big.Int)}
+var chainConfig = &core.ChainConfig{HomesteadBlock: big.NewInt(0)}
 
 // This nil assignment ensures compile time that SimulatedBackend implements bind.ContractBackend.
 var _ bind.ContractBackend = (*SimulatedBackend)(nil)
@@ -73,7 +72,8 @@ func (b *SimulatedBackend) Commit() {
 
 // Rollback aborts all pending transactions, reverting to the last committed state.
 func (b *SimulatedBackend) Rollback() {
-	blocks, _ := core.GenerateChain(chainConfig, b.blockchain.CurrentBlock(), b.database, 1, func(int, *core.BlockGen) {})
+	blocks, _ := core.GenerateChain(b.blockchain.CurrentBlock(), b.database, 1, func(int, *core.BlockGen) {})
+
 	b.pendingBlock = blocks[0]
 	b.pendingState, _ = state.New(b.pendingBlock.Root(), b.database)
 }
@@ -97,8 +97,7 @@ func (b *SimulatedBackend) ContractCall(contract common.Address, data []byte, pe
 		statedb *state.StateDB
 	)
 	if pending {
-		block, statedb = b.pendingBlock, b.pendingState
-		defer statedb.RevertToSnapshot(statedb.Snapshot())
+		block, statedb = b.pendingBlock, b.pendingState.Copy()
 	} else {
 		block = b.blockchain.CurrentBlock()
 		statedb, _ = b.blockchain.State()
@@ -120,7 +119,6 @@ func (b *SimulatedBackend) ContractCall(contract common.Address, data []byte, pe
 		value:    new(big.Int),
 		data:     data,
 	}
-
 	// Execute the call and return
 	vmenv := core.NewEnv(statedb, chainConfig, b.blockchain, msg, block.Header(), vm.Config{})
 	gaspool := new(core.GasPool).AddGas(common.MaxBig)
@@ -148,10 +146,8 @@ func (b *SimulatedBackend) EstimateGasLimit(sender common.Address, contract *com
 	// Create a copy of the currently pending state db to screw around with
 	var (
 		block   = b.pendingBlock
-		statedb = b.pendingState
+		statedb = b.pendingState.Copy()
 	)
-	defer statedb.RevertToSnapshot(statedb.Snapshot())
-
 	// If there's no code to interact with, respond with an appropriate error
 	if contract != nil {
 		if code := statedb.GetCode(*contract); len(code) == 0 {
@@ -182,7 +178,7 @@ func (b *SimulatedBackend) EstimateGasLimit(sender common.Address, contract *com
 // SendTransaction implements ContractTransactor.SendTransaction, delegating the raw
 // transaction injection to the remote node.
 func (b *SimulatedBackend) SendTransaction(tx *types.Transaction) error {
-	blocks, _ := core.GenerateChain(chainConfig, b.blockchain.CurrentBlock(), b.database, 1, func(number int, block *core.BlockGen) {
+	blocks, _ := core.GenerateChain(b.blockchain.CurrentBlock(), b.database, 1, func(number int, block *core.BlockGen) {
 		for _, tx := range b.pendingBlock.Transactions() {
 			block.AddTx(tx)
 		}

appveyor.yml

@@ -1,33 +0,0 @@
-os: Visual Studio 2015
-
-# Clone directly into GOPATH.
-clone_folder: c:\gopath\src\github.com\ethereum\go-ethereum
-clone_depth: 5
-version: "{branch}.{build}"
-environment:
-  global:
-    # Go stuff
-    GOPATH: c:\gopath
-    GO: c:\go\bin\go
-    GOROOT: c:\go
-    CC: C:\msys64\mingw64\bin\gcc.exe
-    # MSYS2 stuff
-    MSYS2_ARCH: x86_64
-    MSYSTEM: MINGW64
-    PATH: C:\msys64\mingw64\bin\;%PATH%
-
-install:
-  - "%GO% version"
-  - "%CC% --version"
-
-build_script:
-  - "%GO% run build\\ci.go install"
-
-test_script:
-  - "%GO% run build\\ci.go test -vet -coverage"
-
-after_build:
-  - "%GO% run build\\ci.go archive -type zip"
-
-artifacts:
-  - path: geth-*.zip

build/ci-notes.md

@@ -1,49 +0,0 @@
-# Debian Packaging
-
-Tagged releases and develop branch commits are available as installable Debian packages
-for Ubuntu. Packages are built for the all Ubuntu versions which are supported by
-Canonical:
-
-- Trusty Tahr (14.04 LTS)
-- Wily Werewolf (15.10)
-- Xenial Xerus (16.04 LTS)
-- Yakkety Yak (16.10)
-
-Packages of develop branch commits have suffix -unstable and cannot be installed alongside
-the stable version. Switching between release streams requires user intervention.
-
-The packages are built and served by launchpad.net. We generate a Debian source package
-for each distribution and upload it. Their builder picks up the source package, builds it
-and installs the new version into the PPA repository. Launchpad requires a valid signature
-by a team member for source package uploads. The signing key is stored in an environment
-variable which Travis CI makes available to certain builds.
-
-We want to build go-ethereum with the most recent version of Go, irrespective of the Go
-version that is available in the main Ubuntu repository. In order to make this possible,
-our PPA depends on the ~gophers/ubuntu/archive PPA. Our source package build-depends on
-golang-1.7, which is co-installable alongside the regular golang package. PPA dependencies
-can be edited at https://launchpad.net/%7Elp-fjl/+archive/ubuntu/geth-ci-testing/+edit-dependencies
-
-## Building Packages Locally (for testing)
-
-You need to run Ubuntu to do test packaging.
-
-Add the gophers PPA and install Go 1.7 and Debian packaging tools:
-
-    $ sudo apt-add-repository ppa:gophers/ubuntu/archive
-    $ sudo apt-get update
-    $ sudo apt-get install build-essential golang-1.7 devscripts debhelper
-
-Create the source packages:
-
-    $ go run build/ci.go debsrc -workdir dist
-
-Then go into the source package directory for your running distribution and build the package:
-
-    $ cd dist/ethereum-unstable-1.5.0+xenial
-    $ dpkg-buildpackage
-
-Built packages are placed in the dist/ directory.
-
-    $ cd ..
-    $ dpkg-deb -c geth-unstable_1.5.0+xenial_amd64.deb

build/ci.go

@@ -1,483 +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/>.
-
-// +build none
-
-/*
-The ci command is called from Continuous Integration scripts.
-
-Usage: go run ci.go <command> <command flags/arguments>
-
-Available commands are:
-
-   install    [ packages... ]                          -- builds packages and executables
-   test       [ -coverage ] [ -vet ] [ packages... ]   -- runs the tests
-   archive    [ -type zip|tar ]                        -- archives build artefacts
-   importkeys                                          -- imports signing keys from env
-   debsrc     [ -sign key-id ] [ -upload dest ]        -- creates a debian source package
-   xgo        [ options ]                              -- cross builds according to options
-
-For all commands, -n prevents execution of external programs (dry run mode).
-
-*/
-package main
-
-import (
-	"bytes"
-	"encoding/base64"
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"time"
-
-	"../internal/build"
-)
-
-var (
-	// Files that end up in the geth*.zip archive.
-	gethArchiveFiles = []string{
-		"COPYING",
-		executablePath("geth"),
-	}
-
-	// Files that end up in the geth-alltools*.zip archive.
-	allToolsArchiveFiles = []string{
-		"COPYING",
-		executablePath("abigen"),
-		executablePath("evm"),
-		executablePath("geth"),
-		executablePath("rlpdump"),
-	}
-
-	// A debian package is created for all executables listed here.
-	debExecutables = []debExecutable{
-		{
-			Name:        "geth",
-			Description: "Ethereum CLI client.",
-		},
-		{
-			Name:        "rlpdump",
-			Description: "Developer utility tool that prints RLP structures.",
-		},
-		{
-			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:        "abigen",
-			Description: "Source code generator to convert Ethereum contract definitions into easy to use, compile-time type-safe Go packages.",
-		},
-	}
-
-	// Distros for which packages are created.
-	// Note: vivid is unsupported because there is no golang-1.6 package for it.
-	debDistros = []string{"trusty", "wily", "xenial", "yakkety"}
-)
-
-var GOBIN, _ = filepath.Abs(filepath.Join("build", "bin"))
-
-func executablePath(name string) string {
-	if runtime.GOOS == "windows" {
-		name += ".exe"
-	}
-	return filepath.Join(GOBIN, name)
-}
-
-func main() {
-	log.SetFlags(log.Lshortfile)
-
-	if _, err := os.Stat(filepath.Join("build", "ci.go")); os.IsNotExist(err) {
-		log.Fatal("this script must be run from the root of the repository")
-	}
-	if len(os.Args) < 2 {
-		log.Fatal("need subcommand as first argument")
-	}
-	switch os.Args[1] {
-	case "install":
-		doInstall(os.Args[2:])
-	case "test":
-		doTest(os.Args[2:])
-	case "archive":
-		doArchive(os.Args[2:])
-	case "debsrc":
-		doDebianSource(os.Args[2:])
-	case "xgo":
-		doXgo(os.Args[2:])
-	default:
-		log.Fatal("unknown command ", os.Args[1])
-	}
-}
-
-// Compiling
-
-func doInstall(cmdline []string) {
-	flag.CommandLine.Parse(cmdline)
-	env := build.Env()
-
-	// Check Go version. People regularly open issues about compilation
-	// failure with outdated Go. This should save them the trouble.
-	if runtime.Version() < "go1.4" && !strings.HasPrefix(runtime.Version(), "devel") {
-		log.Println("You have Go version", runtime.Version())
-		log.Println("go-ethereum requires at least Go version 1.4 and cannot")
-		log.Println("be compiled with an earlier version. Please upgrade your Go installation.")
-		os.Exit(1)
-	}
-
-	// Compile packages given as arguments, or everything if there are no arguments.
-	packages := []string{"./..."}
-	if flag.NArg() > 0 {
-		packages = flag.Args()
-	}
-
-	goinstall := goTool("install", buildFlags(env)...)
-	goinstall.Args = append(goinstall.Args, "-v")
-	goinstall.Args = append(goinstall.Args, packages...)
-	build.MustRun(goinstall)
-}
-
-func buildFlags(env build.Environment) (flags []string) {
-	if os.Getenv("GO_OPENCL") != "" {
-		flags = append(flags, "-tags", "opencl")
-	}
-
-	// Since Go 1.5, the separator char for link time assignments
-	// is '=' and using ' ' prints a warning. However, Go < 1.5 does
-	// not support using '='.
-	sep := " "
-	if runtime.Version() > "go1.5" || strings.Contains(runtime.Version(), "devel") {
-		sep = "="
-	}
-	// Set gitCommit constant via link-time assignment.
-	if env.Commit != "" {
-		flags = append(flags, "-ldflags", "-X main.gitCommit"+sep+env.Commit)
-	}
-	return flags
-}
-
-func goTool(subcmd string, args ...string) *exec.Cmd {
-	gocmd := filepath.Join(runtime.GOROOT(), "bin", "go")
-	cmd := exec.Command(gocmd, subcmd)
-	cmd.Args = append(cmd.Args, args...)
-	cmd.Env = []string{
-		"GOPATH=" + build.GOPATH(),
-		"GOBIN=" + GOBIN,
-	}
-	for _, e := range os.Environ() {
-		if strings.HasPrefix(e, "GOPATH=") || strings.HasPrefix(e, "GOBIN=") {
-			continue
-		}
-		cmd.Env = append(cmd.Env, e)
-	}
-	return cmd
-}
-
-// Running The Tests
-//
-// "tests" also includes static analysis tools such as vet.
-
-func doTest(cmdline []string) {
-	var (
-		vet      = flag.Bool("vet", false, "Whether to run go vet")
-		coverage = flag.Bool("coverage", false, "Whether to record code coverage")
-	)
-	flag.CommandLine.Parse(cmdline)
-	packages := []string{"./..."}
-	if len(flag.CommandLine.Args()) > 0 {
-		packages = flag.CommandLine.Args()
-	}
-
-	// Run analysis tools before the tests.
-	if *vet {
-		build.MustRun(goTool("vet", packages...))
-	}
-
-	// Run the actual tests.
-	gotest := goTool("test")
-	// Test a single package at a time. CI builders are slow
-	// and some tests run into timeouts under load.
-	gotest.Args = append(gotest.Args, "-p", "1")
-	if *coverage {
-		gotest.Args = append(gotest.Args, "-covermode=atomic", "-cover")
-	}
-	gotest.Args = append(gotest.Args, packages...)
-	build.MustRun(gotest)
-}
-
-// Release Packaging
-
-func doArchive(cmdline []string) {
-	var (
-		atype = flag.String("type", "zip", "Type of archive to write (zip|tar)")
-		ext   string
-	)
-	flag.CommandLine.Parse(cmdline)
-	switch *atype {
-	case "zip":
-		ext = ".zip"
-	case "tar":
-		ext = ".tar.gz"
-	default:
-		log.Fatal("unknown archive type: ", atype)
-	}
-
-	env := build.Env()
-	maybeSkipArchive(env)
-
-	base := archiveBasename(env)
-	if err := build.WriteArchive("geth-"+base, ext, gethArchiveFiles); err != nil {
-		log.Fatal(err)
-	}
-	if err := build.WriteArchive("geth-alltools-"+base, ext, allToolsArchiveFiles); err != nil {
-		log.Fatal(err)
-	}
-}
-
-func archiveBasename(env build.Environment) string {
-	// date := time.Now().UTC().Format("200601021504")
-	platform := runtime.GOOS + "-" + runtime.GOARCH
-	archive := platform + "-" + build.VERSION()
-	if env.Commit != "" {
-		archive += "-" + env.Commit[:8]
-	}
-	return archive
-}
-
-// skips archiving for some build configurations.
-func maybeSkipArchive(env build.Environment) {
-	if env.IsPullRequest {
-		log.Printf("skipping because this is a PR build")
-		os.Exit(0)
-	}
-	if env.Branch != "develop" && !strings.HasPrefix(env.Tag, "v1.") {
-		log.Printf("skipping because branch %q, tag %q is not on the whitelist", env.Branch, env.Tag)
-		os.Exit(0)
-	}
-}
-
-// Debian Packaging
-
-func doDebianSource(cmdline []string) {
-	var (
-		signer  = flag.String("signer", "", `Signing key name, also used as package author`)
-		upload  = flag.String("upload", "", `Where to upload the source package (usually "ppa:ethereum/ethereum")`)
-		workdir = flag.String("workdir", "", `Output directory for packages (uses temp dir if unset)`)
-		now     = time.Now()
-	)
-	flag.CommandLine.Parse(cmdline)
-	*workdir = makeWorkdir(*workdir)
-	env := build.Env()
-	maybeSkipArchive(env)
-
-	// Import the signing key.
-	if b64key := os.Getenv("PPA_SIGNING_KEY"); b64key != "" {
-		key, err := base64.StdEncoding.DecodeString(b64key)
-		if err != nil {
-			log.Fatal("invalid base64 PPA_SIGNING_KEY")
-		}
-		gpg := exec.Command("gpg", "--import")
-		gpg.Stdin = bytes.NewReader(key)
-		build.MustRun(gpg)
-	}
-
-	// Create the packages.
-	for _, distro := range debDistros {
-		meta := newDebMetadata(distro, *signer, env, now)
-		pkgdir := stageDebianSource(*workdir, meta)
-		debuild := exec.Command("debuild", "-S", "-sa", "-us", "-uc")
-		debuild.Dir = pkgdir
-		build.MustRun(debuild)
-
-		changes := fmt.Sprintf("%s_%s_source.changes", meta.Name(), meta.VersionString())
-		changes = filepath.Join(*workdir, changes)
-		if *signer != "" {
-			build.MustRunCommand("debsign", changes)
-		}
-		if *upload != "" {
-			build.MustRunCommand("dput", *upload, changes)
-		}
-	}
-}
-
-func makeWorkdir(wdflag string) string {
-	var err error
-	if wdflag != "" {
-		err = os.MkdirAll(wdflag, 0744)
-	} else {
-		wdflag, err = ioutil.TempDir("", "eth-deb-build-")
-	}
-	if err != nil {
-		log.Fatal(err)
-	}
-	return wdflag
-}
-
-func isUnstableBuild(env build.Environment) bool {
-	if env.Branch != "develop" && env.Tag != "" {
-		return false
-	}
-	return true
-}
-
-type debMetadata struct {
-	Env build.Environment
-
-	// go-ethereum version being built. Note that this
-	// is not the debian package version. The package version
-	// is constructed by VersionString.
-	Version string
-
-	Author       string // "name <email>", also selects signing key
-	Distro, Time string
-	Executables  []debExecutable
-}
-
-type debExecutable struct {
-	Name, Description string
-}
-
-func newDebMetadata(distro, author string, env build.Environment, t time.Time) debMetadata {
-	if author == "" {
-		// No signing key, use default author.
-		author = "Ethereum Builds <fjl@ethereum.org>"
-	}
-	return debMetadata{
-		Env:         env,
-		Author:      author,
-		Distro:      distro,
-		Version:     build.VERSION(),
-		Time:        t.Format(time.RFC1123Z),
-		Executables: debExecutables,
-	}
-}
-
-// Name returns the name of the metapackage that depends
-// on all executable packages.
-func (meta debMetadata) Name() string {
-	if isUnstableBuild(meta.Env) {
-		return "ethereum-unstable"
-	}
-	return "ethereum"
-}
-
-// VersionString returns the debian version of the packages.
-func (meta debMetadata) VersionString() string {
-	vsn := meta.Version
-	if meta.Env.Buildnum != "" {
-		vsn += "+build" + meta.Env.Buildnum
-	}
-	if meta.Distro != "" {
-		vsn += "+" + meta.Distro
-	}
-	return vsn
-}
-
-// ExeList returns the list of all executable packages.
-func (meta debMetadata) ExeList() string {
-	names := make([]string, len(meta.Executables))
-	for i, e := range meta.Executables {
-		names[i] = meta.ExeName(e)
-	}
-	return strings.Join(names, ", ")
-}
-
-// ExeName returns the package name of an executable package.
-func (meta debMetadata) ExeName(exe debExecutable) string {
-	if isUnstableBuild(meta.Env) {
-		return exe.Name + "-unstable"
-	}
-	return exe.Name
-}
-
-// ExeConflicts returns the content of the Conflicts field
-// for executable packages.
-func (meta debMetadata) ExeConflicts(exe debExecutable) string {
-	if isUnstableBuild(meta.Env) {
-		// Set up the conflicts list so that the *-unstable packages
-		// cannot be installed alongside the regular version.
-		//
-		// https://www.debian.org/doc/debian-policy/ch-relationships.html
-		// is very explicit about Conflicts: and says that Breaks: should
-		// be preferred and the conflicting files should be handled via
-		// alternates. We might do this eventually but using a conflict is
-		// easier now.
-		return "ethereum, " + exe.Name
-	}
-	return ""
-}
-
-func stageDebianSource(tmpdir string, meta debMetadata) (pkgdir string) {
-	pkg := meta.Name() + "-" + meta.VersionString()
-	pkgdir = filepath.Join(tmpdir, pkg)
-	if err := os.Mkdir(pkgdir, 0755); err != nil {
-		log.Fatal(err)
-	}
-
-	// Copy the source code.
-	build.MustRunCommand("git", "checkout-index", "-a", "--prefix", pkgdir+string(filepath.Separator))
-
-	// Put the debian build files in place.
-	debian := filepath.Join(pkgdir, "debian")
-	build.Render("build/deb.rules", filepath.Join(debian, "rules"), 0755, meta)
-	build.Render("build/deb.changelog", filepath.Join(debian, "changelog"), 0644, meta)
-	build.Render("build/deb.control", filepath.Join(debian, "control"), 0644, meta)
-	build.Render("build/deb.copyright", filepath.Join(debian, "copyright"), 0644, meta)
-	build.RenderString("8\n", filepath.Join(debian, "compat"), 0644, meta)
-	build.RenderString("3.0 (native)\n", filepath.Join(debian, "source/format"), 0644, meta)
-	for _, exe := range meta.Executables {
-		install := filepath.Join(debian, meta.ExeName(exe)+".install")
-		docs := filepath.Join(debian, meta.ExeName(exe)+".docs")
-		build.Render("build/deb.install", install, 0644, exe)
-		build.Render("build/deb.docs", docs, 0644, exe)
-	}
-
-	return pkgdir
-}
-
-// Cross compilation
-
-func doXgo(cmdline []string) {
-	flag.CommandLine.Parse(cmdline)
-	env := build.Env()
-
-	// Make sure xgo is available for cross compilation
-	gogetxgo := goTool("get", "github.com/karalabe/xgo")
-	build.MustRun(gogetxgo)
-
-	// Execute the actual cross compilation
-	xgo := xgoTool(append(buildFlags(env), flag.Args()...))
-	build.MustRun(xgo)
-}
-
-func xgoTool(args []string) *exec.Cmd {
-	cmd := exec.Command(filepath.Join(GOBIN, "xgo"), args...)
-	cmd.Env = []string{
-		"GOPATH=" + build.GOPATH(),
-		"GOBIN=" + GOBIN,
-	}
-	for _, e := range os.Environ() {
-		if strings.HasPrefix(e, "GOPATH=") || strings.HasPrefix(e, "GOBIN=") {
-			continue
-		}
-		cmd.Env = append(cmd.Env, e)
-	}
-	return cmd
-}

build/deb.changelog

@@ -1,5 +0,0 @@
-{{.Name}} ({{.VersionString}}) {{.Distro}}; urgency=low
-
-  * git build of {{.Env.Commit}}
-
- -- {{.Author}}  {{.Time}}

build/deb.control

@@ -1,25 +0,0 @@
-Source: {{.Name}}
-Section: science
-Priority: extra
-Maintainer: {{.Author}}
-Build-Depends: debhelper (>= 8.0.0), golang-1.7
-Standards-Version: 3.9.5
-Homepage: https://ethereum.org
-Vcs-Git: git://github.com/ethereum/go-ethereum.git
-Vcs-Browser: https://github.com/ethereum/go-ethereum
-
-Package: {{.Name}}
-Architecture: any
-Depends: ${misc:Depends}, {{.ExeList}}
-Description: Meta-package to install geth and other tools
- Meta-package to install geth and other tools
- 
-{{range .Executables}}
-Package: {{$.ExeName .}}
-Conflicts: {{$.ExeConflicts .}}
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}
-Built-Using: ${misc:Built-Using}
-Description: {{.Description}}
- {{.Description}}
-{{end}}

build/deb.copyright

@@ -1,14 +0,0 @@
-Copyright 2016 The go-ethereum Authors
-
-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/>.

build/deb.docs

@@ -1 +0,0 @@
-AUTHORS

build/deb.install

@@ -1 +0,0 @@
-build/bin/{{.Name}} usr/bin

build/deb.rules

@@ -1,13 +0,0 @@
-#!/usr/bin/make -f
-# -*- makefile -*-
-
-# Uncomment this to turn on verbose mode.
-#export DH_VERBOSE=1
-
-override_dh_auto_build:
-	build/env.sh /usr/lib/go-1.7/bin/go run build/ci.go install -git-commit={{.Env.Commit}} -git-branch={{.Env.Branch}} -git-tag={{.Env.Tag}} -buildnum={{.Env.Buildnum}} -pull-request={{.Env.IsPullRequest}}
-
-override_dh_auto_test:
-
-%:
-	dh $@

build/env.sh

@@ -20,8 +20,9 @@ fi
 
 # Set up the environment to use the workspace.
 # Also add Godeps workspace so we build using canned dependencies.
-GOPATH="$workspace"
-export GOPATH
+GOPATH="$ethdir/go-ethereum/Godeps/_workspace:$workspace"
+GOBIN="$PWD/build/bin"
+export GOPATH GOBIN
 
 # Run the command inside the workspace.
 cd "$ethdir/go-ethereum"

build/flags.sh

@@ -0,0 +1,22 @@
+#!/bin/sh
+
+set -e
+
+if [ ! -f "build/env.sh" ]; then
+    echo "$0 must be run from the root of the repository."
+    exit 2
+fi
+
+# Since Go 1.5, the separator char for link time assignments
+# is '=' and using ' ' prints a warning. However, Go < 1.5 does
+# not support using '='.
+sep=$(go version | awk '{ if ($3 >= "go1.5" || index($3, "devel")) print "="; else print " "; }' -)
+
+# set gitCommit when running from a Git checkout.
+if [ -f ".git/HEAD" ]; then
+    echo "-ldflags '-X main.gitCommit$sep$(git rev-parse HEAD)'"
+fi
+
+if [ ! -z "$GO_OPENCL" ]; then
+   echo "-tags opencl"
+fi

build/test-global-coverage.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+set -e
+echo "" > coverage.txt
+
+for d in $(find ./* -maxdepth 10 -type d -not -path "./build" -not -path "./Godeps/*" ); do
+    if ls $d/*.go &> /dev/null; then
+        go test  -coverprofile=profile.out -covermode=atomic $d
+        if [ -f profile.out ]; then
+            cat profile.out >> coverage.txt
+            echo '<<<<<< EOF' >> coverage.txt
+            rm profile.out
+        fi
+    fi
+done

build/update-license.go

@@ -49,6 +49,7 @@ var (
 		// don't relicense vendored sources
 		"crypto/sha3/", "crypto/ecies/", "logger/glog/",
 		"crypto/secp256k1/curve.go",
+		"trie/arc.go",
 	}
 
 	// paths with this prefix are licensed as GPL. all other files are LGPL.

build/win-ci-compile.bat

@@ -0,0 +1,26 @@
+@echo off
+if not exist .\build\win-ci-compile.bat (
+   echo This script must be run from the root of the repository.
+   exit /b
+)
+if not defined GOPATH (
+   echo GOPATH is not set.
+   exit /b
+)
+
+set GOPATH=%GOPATH%;%cd%\Godeps\_workspace
+set GOBIN=%cd%\build\bin
+
+rem set gitCommit when running from a Git checkout.
+set goLinkFlags=""
+if exist ".git\HEAD" (
+   where /q git
+   if not errorlevel 1 (
+      for /f %%h in ('git rev-parse HEAD') do (
+          set goLinkFlags="-X main.gitCommit=%%h"
+      )
+   )
+)
+
+@echo on
+go install -v -ldflags %goLinkFlags% ./...

build/win-ci-test.bat

@@ -0,0 +1,15 @@
+@echo off
+if not exist .\build\win-ci-test.bat (
+   echo This script must be run from the root of the repository.
+   exit /b
+)
+if not defined GOPATH (
+   echo GOPATH is not set.
+   exit /b
+)
+
+set GOPATH=%GOPATH%;%cd%\Godeps\_workspace
+set GOBIN=%cd%\build\bin
+
+@echo on
+go test ./...

circle.yml

@@ -1,32 +0,0 @@
-machine:
-  services:
-    - docker
-
-dependencies:
-  cache_directories:
-    - "~/.ethash" # Cache the ethash DAG generated by hive for consecutive builds
-    - "~/.docker" # Cache all docker images manually to avoid lengthy rebuilds
-  override:
-    # Restore all previously cached docker images
-    - mkdir -p ~/.docker
-    - for img in `ls ~/.docker`; do docker load -i ~/.docker/$img; done
-
-    # Pull in and hive, restore cached ethash DAGs and do a dry run
-    - go get -u github.com/karalabe/hive
-    - (cd ~/.go_workspace/src/github.com/karalabe/hive && mkdir -p workspace/ethash/ ~/.ethash)
-    - (cd ~/.go_workspace/src/github.com/karalabe/hive && cp -r ~/.ethash/. workspace/ethash/)
-    - (cd ~/.go_workspace/src/github.com/karalabe/hive && hive --docker-noshell --client=NONE --test=. --sim=. --loglevel=6)
-
-    # Cache all the docker images and the ethash DAGs
-    - for img in `docker images | grep -v "^<none>" | tail -n +2 | awk '{print $1}'`; do docker save $img > ~/.docker/`echo $img | tr '/' ':'`.tar; done
-    - cp -r ~/.go_workspace/src/github.com/karalabe/hive/workspace/ethash/. ~/.ethash
-
-test:
-  override:
-    # Build Geth and move into a known folder
-    - make geth
-    - cp ./build/bin/geth $HOME/geth
-
-    # Run hive and move all generated logs into the public artifacts folder
-    - (cd ~/.go_workspace/src/github.com/karalabe/hive && hive --docker-noshell --client=go-ethereum:local --override=$HOME/geth --test=. --sim=.)
-    - cp -r ~/.go_workspace/src/github.com/karalabe/hive/workspace/logs/* $CIRCLE_ARTIFACTS

cmd/ethtest/main.go

@@ -74,13 +74,12 @@ func runTestWithReader(test string, r io.Reader) error {
 	var err error
 	switch strings.ToLower(test) {
 	case "bk", "block", "blocktest", "blockchaintest", "blocktests", "blockchaintests":
-		err = tests.RunBlockTestWithReader(params.MainNetHomesteadBlock, params.MainNetDAOForkBlock, params.MainNetHomesteadGasRepriceBlock, r, skipTests)
+		err = tests.RunBlockTestWithReader(params.MainNetHomesteadBlock, r, skipTests)
 	case "st", "state", "statetest", "statetests":
-		rs := &params.ChainConfig{HomesteadBlock: params.MainNetHomesteadBlock, DAOForkBlock: params.MainNetDAOForkBlock, DAOForkSupport: true, EIP150Block: params.MainNetHomesteadGasRepriceBlock}
+		rs := tests.RuleSet{HomesteadBlock: params.MainNetHomesteadBlock}
 		err = tests.RunStateTestWithReader(rs, r, skipTests)
 	case "tx", "transactiontest", "transactiontests":
-		rs := &params.ChainConfig{HomesteadBlock: params.MainNetHomesteadBlock, DAOForkBlock: params.MainNetDAOForkBlock, DAOForkSupport: true, EIP150Block: params.MainNetHomesteadGasRepriceBlock}
-		err = tests.RunTransactionTestsWithReader(rs, r, skipTests)
+		err = tests.RunTransactionTestsWithReader(r, skipTests)
 	case "vm", "vmtest", "vmtests":
 		err = tests.RunVmTestWithReader(r, skipTests)
 	case "rlp", "rlptest", "rlptests":

cmd/evm/main.go

@@ -30,10 +30,8 @@ import (
 	"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/glog"
-	"github.com/ethereum/go-ethereum/params"
 	"gopkg.in/urfave/cli.v1"
 )
 
@@ -143,9 +141,7 @@ func run(ctx *cli.Context) error {
 		)
 	} else {
 		receiver := statedb.CreateAccount(common.StringToAddress("receiver"))
-
-		code := common.Hex2Bytes(ctx.GlobalString(CodeFlag.Name))
-		receiver.SetCode(crypto.Keccak256Hash(code), code)
+		receiver.SetCode(common.Hex2Bytes(ctx.GlobalString(CodeFlag.Name)))
 		ret, err = vmenv.Call(
 			sender,
 			receiver.Address(),
@@ -158,7 +154,7 @@ func run(ctx *cli.Context) error {
 	vmdone := time.Since(tstart)
 
 	if ctx.GlobalBool(DumpFlag.Name) {
-		statedb.Commit(true)
+		statedb.Commit()
 		fmt.Println(string(statedb.Dump()))
 	}
 	vm.StdErrFormat(vmenv.StructLogs())
@@ -219,30 +215,27 @@ func NewEnv(state *state.StateDB, transactor common.Address, value *big.Int, cfg
 	return env
 }
 
-// ruleSet implements vm.ChainConfig and will always default to the homestead rule set.
+// ruleSet implements vm.RuleSet 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) RuleSet() vm.RuleSet        { return ruleSet{} }
+func (self *VMEnv) Vm() vm.Vm                  { return self.evm }
+func (self *VMEnv) Db() vm.Database            { return self.state }
+func (self *VMEnv) MakeSnapshot() vm.Database  { return self.state.Copy() }
+func (self *VMEnv) SetSnapshot(db vm.Database) { self.state.Set(db.(*state.StateDB)) }
+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()

cmd/geth/dao_test.go

@@ -1,232 +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 (
-	"io/ioutil"
-	"math/big"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/params"
-)
-
-// Genesis block for nodes which don't care about the DAO fork (i.e. not configured)
-var daoOldGenesis = `{
-	"alloc"      : {},
-	"coinbase"   : "0x0000000000000000000000000000000000000000",
-	"difficulty" : "0x20000",
-	"extraData"  : "",
-	"gasLimit"   : "0x2fefd8",
-	"nonce"      : "0x0000000000000042",
-	"mixhash"    : "0x0000000000000000000000000000000000000000000000000000000000000000",
-	"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
-	"timestamp"  : "0x00",
-	"config"     : {}
-}`
-
-// Genesis block for nodes which actively oppose the DAO fork
-var daoNoForkGenesis = `{
-	"alloc"      : {},
-	"coinbase"   : "0x0000000000000000000000000000000000000000",
-	"difficulty" : "0x20000",
-	"extraData"  : "",
-	"gasLimit"   : "0x2fefd8",
-	"nonce"      : "0x0000000000000042",
-	"mixhash"    : "0x0000000000000000000000000000000000000000000000000000000000000000",
-	"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
-	"timestamp"  : "0x00",
-	"config"     : {
-		"daoForkBlock"   : 314,
-		"daoForkSupport" : false
-	}
-}`
-
-// Genesis block for nodes which actively support the DAO fork
-var daoProForkGenesis = `{
-	"alloc"      : {},
-	"coinbase"   : "0x0000000000000000000000000000000000000000",
-	"difficulty" : "0x20000",
-	"extraData"  : "",
-	"gasLimit"   : "0x2fefd8",
-	"nonce"      : "0x0000000000000042",
-	"mixhash"    : "0x0000000000000000000000000000000000000000000000000000000000000000",
-	"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
-	"timestamp"  : "0x00",
-	"config"     : {
-		"daoForkBlock"   : 314,
-		"daoForkSupport" : true
-	}
-}`
-
-var daoGenesisHash = common.HexToHash("5e1fc79cb4ffa4739177b5408045cd5d51c6cf766133f23f7cd72ee1f8d790e0")
-var daoGenesisForkBlock = big.NewInt(314)
-
-// 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 TestDAODefaultMainnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, "", [][2]bool{{false, false}}, params.MainNetDAOForkBlock, true)
-}
-func TestDAOSupportMainnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, "", [][2]bool{{true, false}}, params.MainNetDAOForkBlock, true)
-}
-func TestDAOOpposeMainnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, "", [][2]bool{{false, true}}, params.MainNetDAOForkBlock, false)
-}
-func TestDAOSwitchToSupportMainnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, "", [][2]bool{{false, true}, {true, false}}, params.MainNetDAOForkBlock, true)
-}
-func TestDAOSwitchToOpposeMainnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, "", [][2]bool{{true, false}, {false, true}}, params.MainNetDAOForkBlock, false)
-}
-func TestDAODefaultTestnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, true, "", [][2]bool{{false, false}}, params.TestNetDAOForkBlock, true)
-}
-func TestDAOSupportTestnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, true, "", [][2]bool{{true, false}}, params.TestNetDAOForkBlock, true)
-}
-func TestDAOOpposeTestnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, true, "", [][2]bool{{false, true}}, params.TestNetDAOForkBlock, false)
-}
-func TestDAOSwitchToSupportTestnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, true, "", [][2]bool{{false, true}, {true, false}}, params.TestNetDAOForkBlock, true)
-}
-func TestDAOSwitchToOpposeTestnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, true, "", [][2]bool{{true, false}, {false, true}}, params.TestNetDAOForkBlock, false)
-}
-func TestDAOInitOldPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{}, nil, false)
-}
-func TestDAODefaultOldPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{false, false}}, params.MainNetDAOForkBlock, true)
-}
-func TestDAOSupportOldPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{true, false}}, params.MainNetDAOForkBlock, true)
-}
-func TestDAOOpposeOldPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{false, true}}, params.MainNetDAOForkBlock, false)
-}
-func TestDAOSwitchToSupportOldPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{false, true}, {true, false}}, params.MainNetDAOForkBlock, true)
-}
-func TestDAOSwitchToOpposeOldPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{true, false}, {false, true}}, params.MainNetDAOForkBlock, false)
-}
-func TestDAOInitNoForkPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{}, daoGenesisForkBlock, false)
-}
-func TestDAODefaultNoForkPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{false, false}}, daoGenesisForkBlock, false)
-}
-func TestDAOSupportNoForkPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{true, false}}, daoGenesisForkBlock, true)
-}
-func TestDAOOpposeNoForkPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{false, true}}, daoGenesisForkBlock, false)
-}
-func TestDAOSwitchToSupportNoForkPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{false, true}, {true, false}}, daoGenesisForkBlock, true)
-}
-func TestDAOSwitchToOpposeNoForkPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{true, false}, {false, true}}, daoGenesisForkBlock, false)
-}
-func TestDAOInitProForkPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{}, daoGenesisForkBlock, true)
-}
-func TestDAODefaultProForkPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{false, false}}, daoGenesisForkBlock, true)
-}
-func TestDAOSupportProForkPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{true, false}}, daoGenesisForkBlock, true)
-}
-func TestDAOOpposeProForkPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{false, true}}, daoGenesisForkBlock, false)
-}
-func TestDAOSwitchToSupportProForkPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{false, true}, {true, false}}, daoGenesisForkBlock, true)
-}
-func TestDAOSwitchToOpposeProForkPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{true, false}, {false, true}}, daoGenesisForkBlock, false)
-}
-
-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)
-
-	// Start a Geth instance with the requested flags set and immediately terminate
-	if genesis != "" {
-		json := filepath.Join(datadir, "genesis.json")
-		if err := ioutil.WriteFile(json, []byte(genesis), 0600); err != nil {
-			t.Fatalf("failed to write genesis file: %v", err)
-		}
-		runGeth(t, "--datadir", datadir, "init", json).cmd.Wait()
-	}
-	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()
-	}
-	// Retrieve the DAO config flag from the database
-	path := filepath.Join(datadir, "chaindata")
-	if testnet && genesis == "" {
-		path = filepath.Join(datadir, "testnet", "chaindata")
-	}
-	db, err := ethdb.NewLDBDatabase(path, 0, 0)
-	if err != nil {
-		t.Fatalf("failed to open test database: %v", err)
-	}
-	defer db.Close()
-
-	genesisHash := common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3")
-	if testnet {
-		genesisHash = common.HexToHash("0x0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303")
-	}
-	if genesis != "" {
-		genesisHash = daoGenesisHash
-	}
-	config, err := core.GetChainConfig(db, genesisHash)
-	if err != nil {
-		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("dao hard-fork block mismatch: have nil, want %v", expectBlock)
-		}
-	} else if expectBlock == nil {
-		t.Errorf("dao hard-fork block mismatch: have %v, want nil", config.DAOForkBlock)
-	} else if config.DAOForkBlock.Cmp(expectBlock) != 0 {
-		t.Errorf("dao hard-fork block mismatch: have %v, want %v", config.DAOForkBlock, expectBlock)
-	}
-	if config.DAOForkSupport != expectVote {
-		t.Errorf("dao hard-fork support mismatch: have %v, want %v", config.DAOForkSupport, expectVote)
-	}
-}

cmd/geth/genesis_test.go

@@ -1,107 +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 (
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-var customGenesisTests = []struct {
-	genesis string
-	query   string
-	result  string
-}{
-	// Plain genesis file without anything extra
-	{
-		genesis: `{
-			"alloc"      : {},
-			"coinbase"   : "0x0000000000000000000000000000000000000000",
-			"difficulty" : "0x20000",
-			"extraData"  : "",
-			"gasLimit"   : "0x2fefd8",
-			"nonce"      : "0x0000000000000042",
-			"mixhash"    : "0x0000000000000000000000000000000000000000000000000000000000000000",
-			"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
-			"timestamp"  : "0x00"
-		}`,
-		query:  "eth.getBlock(0).nonce",
-		result: "0x0000000000000042",
-	},
-	// Genesis file with an empty chain configuration (ensure missing fields work)
-	{
-		genesis: `{
-			"alloc"      : {},
-			"coinbase"   : "0x0000000000000000000000000000000000000000",
-			"difficulty" : "0x20000",
-			"extraData"  : "",
-			"gasLimit"   : "0x2fefd8",
-			"nonce"      : "0x0000000000000042",
-			"mixhash"    : "0x0000000000000000000000000000000000000000000000000000000000000000",
-			"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
-			"timestamp"  : "0x00",
-			"config"     : {}
-		}`,
-		query:  "eth.getBlock(0).nonce",
-		result: "0x0000000000000042",
-	},
-	// Genesis file with specific chain configurations
-	{
-		genesis: `{
-			"alloc"      : {},
-			"coinbase"   : "0x0000000000000000000000000000000000000000",
-			"difficulty" : "0x20000",
-			"extraData"  : "",
-			"gasLimit"   : "0x2fefd8",
-			"nonce"      : "0x0000000000000042",
-			"mixhash"    : "0x0000000000000000000000000000000000000000000000000000000000000000",
-			"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
-			"timestamp"  : "0x00",
-			"config"     : {
-				"homesteadBlock" : 314,
-				"daoForkBlock"   : 141,
-				"daoForkSupport" : true
-			},
-		}`,
-		query:  "eth.getBlock(0).nonce",
-		result: "0x0000000000000042",
-	},
-}
-
-// Tests that initializing Geth with a custom genesis block and chain definitions
-// work properly.
-func TestCustomGenesis(t *testing.T) {
-	for i, tt := range customGenesisTests {
-		// Create a temporary data directory to use and inspect later
-		datadir := tmpdir(t)
-		defer os.RemoveAll(datadir)
-
-		// Initialize the data directory with the custom genesis block
-		json := filepath.Join(datadir, "genesis.json")
-		if err := ioutil.WriteFile(json, []byte(tt.genesis), 0600); err != nil {
-			t.Fatalf("test %d: failed to write genesis file: %v", i, err)
-		}
-		runGeth(t, "--datadir", datadir, "init", json).cmd.Wait()
-
-		// Query the custom genesis block
-		geth := runGeth(t, "--datadir", datadir, "--maxpeers", "0", "--nodiscover", "--nat", "none", "--ipcdisable", "--exec", tt.query, "console")
-		geth.expectRegexp(tt.result)
-		geth.expectExit()
-	}
-}

cmd/geth/main.go

@@ -50,7 +50,7 @@ const (
 	clientIdentifier = "Geth"   // Client identifier to advertise over the network
 	versionMajor     = 1        // Major version component of the current release
 	versionMinor     = 4        // Minor version component of the current release
-	versionPatch     = 19       // Patch 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
 
 	versionOracle = "0xfa7b9770ca4cb04296cac84f37736d4041251cdf" // Ethereum address of the Geth release oracle
@@ -149,6 +149,7 @@ participating.
 		utils.IdentityFlag,
 		utils.UnlockedAccountFlag,
 		utils.PasswordFileFlag,
+		utils.GenesisFileFlag,
 		utils.BootnodesFlag,
 		utils.DataDirFlag,
 		utils.KeyStoreDirFlag,
@@ -163,8 +164,6 @@ participating.
 		utils.MaxPendingPeersFlag,
 		utils.EtherbaseFlag,
 		utils.GasPriceFlag,
-		utils.SupportDAOFork,
-		utils.OpposeDAOFork,
 		utils.MinerThreadsFlag,
 		utils.MiningEnabledFlag,
 		utils.MiningGPUFlag,
@@ -225,6 +224,12 @@ participating.
 		eth.EnableBadBlockReporting = true
 
 		utils.SetupNetwork(ctx)
+
+		// Deprecation warning.
+		if ctx.GlobalIsSet(utils.GenesisFileFlag.Name) {
+			common.PrintDepricationWarning("--genesis is deprecated. Switch to use 'geth init /path/to/file'")
+		}
+
 		return nil
 	}
 

cmd/geth/usage.go

@@ -68,6 +68,7 @@ var AppHelpFlagGroups = []flagGroup{
 			utils.OlympicFlag,
 			utils.TestNetFlag,
 			utils.DevModeFlag,
+			utils.GenesisFileFlag,
 			utils.IdentityFlag,
 			utils.FastSyncFlag,
 			utils.LightKDFFlag,

cmd/gethrpctest/main.go

@@ -26,6 +26,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/eth"
 	"github.com/ethereum/go-ethereum/ethdb"
@@ -129,7 +130,8 @@ func MakeSystemNode(keydir string, privkey string, test *tests.BlockTest) (*node
 	ethConf := &eth.Config{
 		TestGenesisState: db,
 		TestGenesisBlock: test.Genesis,
-		ChainConfig:      &params.ChainConfig{HomesteadBlock: params.MainNetHomesteadBlock},
+		ChainConfig:      &core.ChainConfig{HomesteadBlock: params.MainNetHomesteadBlock},
+		AccountManager:   accman,
 	}
 	if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) { return eth.New(ctx, ethConf) }); err != nil {
 		return nil, err

cmd/utils/cmd.go

@@ -23,7 +23,6 @@ import (
 	"os"
 	"os/signal"
 	"regexp"
-	"runtime"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
@@ -53,16 +52,10 @@ func openLogFile(Datadir string, filename string) *os.File {
 // is redirected to a different file.
 func Fatalf(format string, args ...interface{}) {
 	w := io.MultiWriter(os.Stdout, os.Stderr)
-	if runtime.GOOS == "windows" {
-		// The SameFile check below doesn't work on Windows.
-		// stdout is unlikely to get redirected though, so just print there.
-		w = os.Stdout
-	} else {
-		outf, _ := os.Stdout.Stat()
-		errf, _ := os.Stderr.Stat()
-		if outf != nil && errf != nil && os.SameFile(outf, errf) {
-			w = os.Stderr
-		}
+	outf, _ := os.Stdout.Stat()
+	errf, _ := os.Stderr.Stat()
+	if outf != nil && errf != nil && os.SameFile(outf, errf) {
+		w = os.Stderr
 	}
 	fmt.Fprintf(w, "Fatal: "+format+"\n", args...)
 	logger.Flush()

cmd/utils/flags.go

@@ -22,11 +22,13 @@ import (
 	"io/ioutil"
 	"math"
 	"math/big"
+	"math/rand"
 	"os"
 	"path/filepath"
 	"runtime"
 	"strconv"
 	"strings"
+	"time"
 
 	"github.com/ethereum/ethash"
 	"github.com/ethereum/go-ethereum/accounts"
@@ -124,6 +126,10 @@ var (
 		Name:  "dev",
 		Usage: "Developer mode: pre-configured private network with several debugging flags",
 	}
+	GenesisFileFlag = cli.StringFlag{
+		Name:  "genesis",
+		Usage: "Insert/overwrite the genesis block (JSON format)",
+	}
 	IdentityFlag = cli.StringFlag{
 		Name:  "identity",
 		Usage: "Custom node name",
@@ -155,15 +161,6 @@ var (
 		Name:  "lightkdf",
 		Usage: "Reduce key-derivation RAM & CPU usage at some expense of KDF strength",
 	}
-	// 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
 	// TODO: refactor CPU vs GPU mining flags
 	MiningEnabledFlag = cli.BoolFlag{
@@ -537,6 +534,20 @@ func MakeWSRpcHost(ctx *cli.Context) string {
 	return ctx.GlobalString(WSListenAddrFlag.Name)
 }
 
+// MakeGenesisBlock loads up a genesis block from an input file specified in the
+// command line, or returns the empty string if none set.
+func MakeGenesisBlock(ctx *cli.Context) string {
+	genesis := ctx.GlobalString(GenesisFileFlag.Name)
+	if genesis == "" {
+		return ""
+	}
+	data, err := ioutil.ReadFile(genesis)
+	if err != nil {
+		Fatalf("Failed to load custom genesis file: %v", err)
+	}
+	return string(data)
+}
+
 // MakeDatabaseHandles raises out the number of allowed file handles per process
 // for Geth and returns half of the allowance to assign to the database.
 func MakeDatabaseHandles() int {
@@ -665,9 +676,20 @@ func MakeSystemNode(name, version string, relconf release.Config, extra []byte,
 	}
 	// Configure the Ethereum service
 	accman := MakeAccountManager(ctx)
+
+	// initialise new random number generator
+	rand := rand.New(rand.NewSource(time.Now().UnixNano()))
+	// get enabled jit flag
 	jitEnabled := ctx.GlobalBool(VMEnableJitFlag.Name)
+	// if the jit is not enabled enable it for 10 pct of the people
+	if !jitEnabled && rand.Float64() < 0.1 {
+		jitEnabled = true
+		glog.V(logger.Info).Infoln("You're one of the lucky few that will try out the JIT VM (random). If you get a consensus failure please be so kind to report this incident with the block hash that failed. You can switch to the regular VM by setting --jitvm=false")
+	}
+
 	ethConf := &eth.Config{
 		ChainConfig:             MustMakeChainConfig(ctx),
+		Genesis:                 MakeGenesisBlock(ctx),
 		FastSync:                ctx.GlobalBool(FastSyncFlag.Name),
 		BlockChainVersion:       ctx.GlobalInt(BlockchainVersionFlag.Name),
 		DatabaseCache:           ctx.GlobalInt(CacheFlag.Name),
@@ -700,13 +722,17 @@ func MakeSystemNode(name, version string, relconf release.Config, extra []byte,
 		if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
 			ethConf.NetworkId = 1
 		}
-		ethConf.Genesis = core.OlympicGenesisBlock()
+		if !ctx.GlobalIsSet(GenesisFileFlag.Name) {
+			ethConf.Genesis = core.OlympicGenesisBlock()
+		}
 
 	case ctx.GlobalBool(TestNetFlag.Name):
 		if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
 			ethConf.NetworkId = 2
 		}
-		ethConf.Genesis = core.TestNetGenesisBlock()
+		if !ctx.GlobalIsSet(GenesisFileFlag.Name) {
+			ethConf.Genesis = core.TestNetGenesisBlock()
+		}
 		state.StartingNonce = 1048576 // (2**20)
 
 	case ctx.GlobalBool(DevModeFlag.Name):
@@ -721,7 +747,9 @@ func MakeSystemNode(name, version string, relconf release.Config, extra []byte,
 			stackConf.ListenAddr = ":0"
 		}
 		// Override the Ethereum protocol configs
-		ethConf.Genesis = core.OlympicGenesisBlock()
+		if !ctx.GlobalIsSet(GenesisFileFlag.Name) {
+			ethConf.Genesis = core.OlympicGenesisBlock()
+		}
 		if !ctx.GlobalIsSet(GasPriceFlag.Name) {
 			ethConf.GasPrice = new(big.Int)
 		}
@@ -769,7 +797,7 @@ func SetupNetwork(ctx *cli.Context) {
 }
 
 // MustMakeChainConfig reads the chain configuration from the database in ctx.Datadir.
-func MustMakeChainConfig(ctx *cli.Context) *params.ChainConfig {
+func MustMakeChainConfig(ctx *cli.Context) *core.ChainConfig {
 	db := MakeChainDatabase(ctx)
 	defer db.Close()
 
@@ -777,101 +805,25 @@ func MustMakeChainConfig(ctx *cli.Context) *params.ChainConfig {
 }
 
 // MustMakeChainConfigFromDb reads the chain configuration from the given database.
-func MustMakeChainConfigFromDb(ctx *cli.Context, db ethdb.Database) *params.ChainConfig {
-	// If the chain is already initialized, use any existing chain configs
-	config := new(params.ChainConfig)
-
+func MustMakeChainConfigFromDb(ctx *cli.Context, db ethdb.Database) *core.ChainConfig {
 	genesis := core.GetBlock(db, core.GetCanonicalHash(db, 0))
+
 	if genesis != nil {
+		// Existing genesis block, use stored config if available.
 		storedConfig, err := core.GetChainConfig(db, genesis.Hash())
-		switch err {
-		case nil:
-			config = storedConfig
-		case core.ChainConfigNotFoundErr:
-			// No configs found, use empty, will populate below
-		default:
+		if err == nil {
+			return storedConfig
+		} else if err != core.ChainConfigNotFoundErr {
 			Fatalf("Could not make chain configuration: %v", err)
 		}
 	}
-	if config.ChainId == nil {
-		config.ChainId = new(big.Int)
+	var homesteadBlockNo *big.Int
+	if ctx.GlobalBool(TestNetFlag.Name) {
+		homesteadBlockNo = params.TestNetHomesteadBlock
+	} else {
+		homesteadBlockNo = params.MainNetHomesteadBlock
 	}
-	// Set any missing fields due to them being unset or system upgrade
-	if config.HomesteadBlock == nil {
-		if ctx.GlobalBool(TestNetFlag.Name) {
-			config.HomesteadBlock = params.TestNetHomesteadBlock
-		} else {
-			config.HomesteadBlock = params.MainNetHomesteadBlock
-		}
-	}
-	if config.DAOForkBlock == nil {
-		if ctx.GlobalBool(TestNetFlag.Name) {
-			config.DAOForkBlock = params.TestNetDAOForkBlock
-		} else {
-			config.DAOForkBlock = params.MainNetDAOForkBlock
-		}
-		config.DAOForkSupport = true
-	}
-	if config.EIP150Block == nil {
-		if ctx.GlobalBool(TestNetFlag.Name) {
-			config.EIP150Block = params.TestNetHomesteadGasRepriceBlock
-		} else {
-			config.EIP150Block = params.MainNetHomesteadGasRepriceBlock
-		}
-	}
-	if config.EIP150Hash == (common.Hash{}) {
-		if ctx.GlobalBool(TestNetFlag.Name) {
-			config.EIP150Hash = params.TestNetHomesteadGasRepriceHash
-		} else {
-			config.EIP150Hash = params.MainNetHomesteadGasRepriceHash
-		}
-	}
-	if config.EIP155Block == nil {
-		if ctx.GlobalBool(TestNetFlag.Name) {
-			config.EIP150Block = params.TestNetSpuriousDragon
-		} else {
-			config.EIP155Block = params.MainNetSpuriousDragon
-		}
-	}
-	if config.EIP158Block == nil {
-		if ctx.GlobalBool(TestNetFlag.Name) {
-			config.EIP158Block = params.TestNetSpuriousDragon
-		} else {
-			config.EIP158Block = params.MainNetSpuriousDragon
-		}
-	}
-	if config.ChainId.BitLen() == 0 {
-		if ctx.GlobalBool(TestNetFlag.Name) {
-			config.ChainId = params.TestNetChainID
-		} else {
-			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
-	}
-	// Temporarilly display a proper message so the user knows which fork its on
-	if !ctx.GlobalBool(TestNetFlag.Name) && (genesis == nil || genesis.Hash() == common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3")) {
-		choice := "SUPPORT"
-		if !config.DAOForkSupport {
-			choice = "OPPOSE"
-		}
-		current := fmt.Sprintf("Geth is currently configured to %s the DAO hard-fork!", choice)
-		howtoswap := fmt.Sprintf("You can change your choice prior to block #%v with --support-dao-fork or --oppose-dao-fork.", config.DAOForkBlock)
-		howtosync := fmt.Sprintf("After the hard-fork block #%v passed, changing chains requires a resync from scratch!", config.DAOForkBlock)
-		separator := strings.Repeat("-", len(howtoswap))
-
-		glog.V(logger.Warn).Info(separator)
-		glog.V(logger.Warn).Info(current)
-		glog.V(logger.Warn).Info(howtoswap)
-		glog.V(logger.Warn).Info(howtosync)
-		glog.V(logger.Warn).Info(separator)
-	}
-	return config
+	return &core.ChainConfig{HomesteadBlock: homesteadBlockNo}
 }
 
 // MakeChainDatabase open an LevelDB using the flags passed to the client and will hard crash if it fails.

common/registrar/ethreg/api.go

@@ -32,12 +32,11 @@ import (
 	"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
+	config  *core.ChainConfig
 	bc      *core.BlockChain
 	chainDb ethdb.Database
 	txPool  *core.TxPool
@@ -46,12 +45,12 @@ type registryAPIBackend struct {
 
 // PrivateRegistarAPI offers various functions to access the Ethereum registry.
 type PrivateRegistarAPI struct {
-	config *params.ChainConfig
+	config *core.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 {
+func NewPrivateRegistarAPI(config *core.ChainConfig, bc *core.BlockChain, chainDb ethdb.Database, txPool *core.TxPool, am *accounts.Manager) *PrivateRegistarAPI {
 	return &PrivateRegistarAPI{
 		config: config,
 		be: &registryAPIBackend{

console/console_test.go

@@ -30,10 +30,10 @@ import (
 
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/eth"
 	"github.com/ethereum/go-ethereum/internal/jsre"
 	"github.com/ethereum/go-ethereum/node"
-	"github.com/ethereum/go-ethereum/params"
 )
 
 const (
@@ -100,10 +100,10 @@ func newTester(t *testing.T, confOverride func(*eth.Config)) *tester {
 		t.Fatalf("failed to create node: %v", err)
 	}
 	ethConf := &eth.Config{
-		ChainConfig:    &params.ChainConfig{ChainId: new(big.Int), HomesteadBlock: new(big.Int)},
+		ChainConfig:    &core.ChainConfig{HomesteadBlock: new(big.Int)},
 		Etherbase:      common.HexToAddress(testAddress),
-		PowTest:        true,
 		AccountManager: accman,
+		PowTest:        true,
 	}
 	if confOverride != nil {
 		confOverride(ethConf)

containers/docker/master-alpine/Dockerfile

@@ -1,11 +1,11 @@
 FROM alpine:3.3
 
 RUN \
-  apk add --update go git make gcc musl-dev         && \
-  git clone https://github.com/ethereum/go-ethereum && \
-  (cd go-ethereum && make geth)                     && \
-  cp go-ethereum/build/bin/geth /geth               && \
-  apk del go git make gcc musl-dev                  && \
+  apk add --update go git make gcc musl-dev gmp-dev gmp && \
+  git clone https://github.com/ethereum/go-ethereum     && \
+  (cd go-ethereum && make geth)                         && \
+  cp go-ethereum/build/bin/geth /geth                   && \
+  apk del go git make gcc musl-dev gmp-dev              && \
   rm -rf /go-ethereum && rm -rf /var/cache/apk/*
 
 EXPOSE 8545

core/bench_test.go

@@ -163,12 +163,12 @@ func benchInsertChain(b *testing.B, disk bool, gen func(int, *BlockGen)) {
 	// Generate a chain of b.N blocks using the supplied block
 	// generator function.
 	genesis := WriteGenesisBlockForTesting(db, GenesisAccount{benchRootAddr, benchRootFunds})
-	chain, _ := GenerateChain(params.TestChainConfig, genesis, db, b.N, gen)
+	chain, _ := GenerateChain(genesis, db, b.N, gen)
 
 	// Time the insertion of the new chain.
 	// State and blocks are stored in the same DB.
 	evmux := new(event.TypeMux)
-	chainman, _ := NewBlockChain(db, &params.ChainConfig{HomesteadBlock: new(big.Int)}, FakePow{}, evmux)
+	chainman, _ := NewBlockChain(db, &ChainConfig{HomesteadBlock: new(big.Int)}, FakePow{}, evmux)
 	defer chainman.Stop()
 	b.ReportAllocs()
 	b.ResetTimer()

core/block_validator.go

@@ -41,13 +41,13 @@ var (
 //
 // BlockValidator implements Validator.
 type BlockValidator struct {
-	config *params.ChainConfig // Chain configuration options
-	bc     *BlockChain         // Canonical block chain
-	Pow    pow.PoW             // Proof of work used for validating
+	config *ChainConfig // Chain configuration options
+	bc     *BlockChain  // Canonical block chain
+	Pow    pow.PoW      // Proof of work used for validating
 }
 
 // NewBlockValidator returns a new block validator which is safe for re-use
-func NewBlockValidator(config *params.ChainConfig, blockchain *BlockChain, pow pow.PoW) *BlockValidator {
+func NewBlockValidator(config *ChainConfig, blockchain *BlockChain, pow pow.PoW) *BlockValidator {
 	validator := &BlockValidator{
 		config: config,
 		Pow:    pow,
@@ -128,7 +128,7 @@ func (v *BlockValidator) ValidateState(block, parent *types.Block, statedb *stat
 	}
 	// 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 {
+	if root := statedb.IntermediateRoot(); header.Root != root {
 		return fmt.Errorf("invalid merkle root: header=%x computed=%x", header.Root, root)
 	}
 	return nil
@@ -203,7 +203,7 @@ func (v *BlockValidator) ValidateHeader(header, parent *types.Header, checkPow b
 // Validates a header. Returns an error if the header is invalid.
 //
 // See YP section 4.3.4. "Block Header Validity"
-func ValidateHeader(config *params.ChainConfig, pow pow.PoW, header *types.Header, parent *types.Header, checkPow, uncle bool) error {
+func ValidateHeader(config *ChainConfig, pow pow.PoW, header *types.Header, parent *types.Header, checkPow, uncle bool) error {
 	if big.NewInt(int64(len(header.Extra))).Cmp(params.MaximumExtraDataSize) == 1 {
 		return fmt.Errorf("Header extra data too long (%d)", len(header.Extra))
 	}
@@ -247,22 +247,13 @@ func ValidateHeader(config *params.ChainConfig, pow pow.PoW, header *types.Heade
 			return &BlockNonceErr{header.Number, header.Hash(), header.Nonce.Uint64()}
 		}
 	}
-	// If all checks passed, validate the extra-data field for hard forks
-	if err := ValidateDAOHeaderExtraData(config, header); err != nil {
-		return err
-	}
-	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)
-		}
-	}
 	return nil
 }
 
 // CalcDifficulty is the difficulty adjustment algorithm. It returns
 // the difficulty that a new block should have when created at time
 // given the parent block's time and difficulty.
-func CalcDifficulty(config *params.ChainConfig, time, parentTime uint64, parentNumber, parentDiff *big.Int) *big.Int {
+func CalcDifficulty(config *ChainConfig, time, parentTime uint64, parentNumber, parentDiff *big.Int) *big.Int {
 	if config.IsHomestead(new(big.Int).Add(parentNumber, common.Big1)) {
 		return calcDifficultyHomestead(time, parentTime, parentNumber, parentDiff)
 	} else {

core/block_validator_test.go

@@ -27,13 +27,11 @@ import (
 	"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 {
-	return params.TestChainConfig
-	//return &params.ChainConfig{HomesteadBlock: big.NewInt(0)}
+func testChainConfig() *ChainConfig {
+	return &ChainConfig{HomesteadBlock: big.NewInt(0)}
 }
 
 func proc() (Validator, *BlockChain) {
@@ -53,15 +51,15 @@ func TestNumber(t *testing.T) {
 	_, chain := proc()
 
 	statedb, _ := state.New(chain.Genesis().Root(), chain.chainDb)
-	cfg := testChainConfig()
-	header := makeHeader(cfg, chain.Genesis(), statedb)
+	header := makeHeader(chain.Genesis(), statedb)
 	header.Number = big.NewInt(3)
+	cfg := testChainConfig()
 	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)
+	header = makeHeader(chain.Genesis(), statedb)
 	err = ValidateHeader(cfg, pow, header, chain.Genesis().Header(), false, false)
 	if err == BlockNumberErr {
 		t.Errorf("didn't expect block number error")

core/blockchain.go

@@ -38,7 +38,6 @@ import (
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/logger/glog"
 	"github.com/ethereum/go-ethereum/metrics"
-	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/pow"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/trie"
@@ -81,7 +80,7 @@ const (
 // included in the canonical one where as GetBlockByNumber always represents the
 // canonical chain.
 type BlockChain struct {
-	config *params.ChainConfig // chain & network configuration
+	config *ChainConfig // chain & network configuration
 
 	hc           *HeaderChain
 	chainDb      ethdb.Database
@@ -96,11 +95,10 @@ type BlockChain struct {
 	currentBlock     *types.Block // Current head of the block chain
 	currentFastBlock *types.Block // Current head of the fast-sync chain (may be above the block chain!)
 
-	stateCache   *state.StateDB // State database to reuse between imports (contains state cache)
-	bodyCache    *lru.Cache     // Cache for the most recent block bodies
-	bodyRLPCache *lru.Cache     // Cache for the most recent block bodies in RLP encoded format
-	blockCache   *lru.Cache     // Cache for the most recent entire blocks
-	futureBlocks *lru.Cache     // future blocks are blocks added for later processing
+	bodyCache    *lru.Cache // Cache for the most recent block bodies
+	bodyRLPCache *lru.Cache // Cache for the most recent block bodies in RLP encoded format
+	blockCache   *lru.Cache // Cache for the most recent entire blocks
+	futureBlocks *lru.Cache // future blocks are blocks added for later processing
 
 	quit    chan struct{} // blockchain quit channel
 	running int32         // running must be called atomically
@@ -116,7 +114,7 @@ type BlockChain struct {
 // NewBlockChain returns a fully initialised block chain using information
 // available in the database. It initialiser the default Ethereum Validator and
 // Processor.
-func NewBlockChain(chainDb ethdb.Database, config *params.ChainConfig, pow pow.PoW, mux *event.TypeMux) (*BlockChain, error) {
+func NewBlockChain(chainDb ethdb.Database, config *ChainConfig, pow pow.PoW, mux *event.TypeMux) (*BlockChain, error) {
 	bodyCache, _ := lru.New(bodyCacheLimit)
 	bodyRLPCache, _ := lru.New(bodyCacheLimit)
 	blockCache, _ := lru.New(blockCacheLimit)
@@ -200,18 +198,11 @@ func (self *BlockChain) loadLastState() error {
 			self.currentFastBlock = block
 		}
 	}
-	// Initialize a statedb cache to ensure singleton account bloom filter generation
-	statedb, err := state.New(self.currentBlock.Root(), self.chainDb)
-	if err != nil {
-		return err
-	}
-	self.stateCache = statedb
-	self.stateCache.GetAccount(common.Address{})
-
 	// Issue a status log and return
 	headerTd := self.GetTd(self.hc.CurrentHeader().Hash())
 	blockTd := self.GetTd(self.currentBlock.Hash())
 	fastTd := self.GetTd(self.currentFastBlock.Hash())
+
 	glog.V(logger.Info).Infof("Last header: #%d [%x…] TD=%v", self.hc.CurrentHeader().Number, self.hc.CurrentHeader().Hash().Bytes()[:4], headerTd)
 	glog.V(logger.Info).Infof("Last block: #%d [%x…] TD=%v", self.currentBlock.Number(), self.currentBlock.Hash().Bytes()[:4], blockTd)
 	glog.V(logger.Info).Infof("Fast block: #%d [%x…] TD=%v", self.currentFastBlock.Number(), self.currentFastBlock.Hash().Bytes()[:4], fastTd)
@@ -270,7 +261,7 @@ func (self *BlockChain) FastSyncCommitHead(hash common.Hash) error {
 	if block == nil {
 		return fmt.Errorf("non existent block [%x…]", hash[:4])
 	}
-	if _, err := trie.NewSecure(block.Root(), self.chainDb, 0); err != nil {
+	if _, err := trie.NewSecure(block.Root(), self.chainDb); err != nil {
 		return err
 	}
 	// If all checks out, manually set the head block
@@ -358,12 +349,7 @@ func (self *BlockChain) AuxValidator() pow.PoW { return self.pow }
 
 // State returns a new mutable state based on the current HEAD block.
 func (self *BlockChain) State() (*state.StateDB, error) {
-	return self.StateAt(self.CurrentBlock().Root())
-}
-
-// StateAt returns a new mutable state based on a particular point in time.
-func (self *BlockChain) StateAt(root common.Hash) (*state.StateDB, error) {
-	return self.stateCache.New(root)
+	return state.New(self.CurrentBlock().Root(), self.chainDb)
 }
 
 // Reset purges the entire blockchain, restoring it to its genesis state.
@@ -777,20 +763,13 @@ func (self *BlockChain) WriteBlock(block *types.Block) (status WriteStatus, err
 	if ptd == nil {
 		return NonStatTy, ParentError(block.ParentHash())
 	}
-	// Make sure no inconsistent state is leaked during insertion
-	self.mu.Lock()
-	defer self.mu.Unlock()
 
 	localTd := self.GetTd(self.currentBlock.Hash())
 	externTd := new(big.Int).Add(block.Difficulty(), ptd)
 
-	// Irrelevant of the canonical status, write the block itself to the database
-	if err := self.hc.WriteTd(block.Hash(), externTd); err != nil {
-		glog.Fatalf("failed to write block total difficulty: %v", err)
-	}
-	if err := WriteBlock(self.chainDb, block); err != nil {
-		glog.Fatalf("failed to write block contents: %v", err)
-	}
+	// Make sure no inconsistent state is leaked during insertion
+	self.mu.Lock()
+	defer self.mu.Unlock()
 
 	// If the total difficulty is higher than our known, add it to the canonical chain
 	// Second clause in the if statement reduces the vulnerability to selfish mining.
@@ -802,11 +781,20 @@ func (self *BlockChain) WriteBlock(block *types.Block) (status WriteStatus, err
 				return NonStatTy, err
 			}
 		}
-		self.insert(block) // Insert the block as the new head of the chain
+		// Insert the block as the new head of the chain
+		self.insert(block)
 		status = CanonStatTy
 	} else {
 		status = SideStatTy
 	}
+	// Irrelevant of the canonical status, write the block itself to the database
+	if err := self.hc.WriteTd(block.Hash(), externTd); err != nil {
+		glog.Fatalf("failed to write block total difficulty: %v", err)
+	}
+	if err := WriteBlock(self.chainDb, block); err != nil {
+		glog.Fatalf("failed to write block contents: %v", err)
+	}
+
 	self.futureBlocks.Remove(block.Hash())
 
 	return
@@ -825,16 +813,20 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) {
 	// faster than direct delivery and requires much less mutex
 	// acquiring.
 	var (
-		stats         = insertStats{startTime: time.Now()}
+		stats         struct{ queued, processed, ignored int }
 		events        = make([]interface{}, 0, len(chain))
 		coalescedLogs vm.Logs
-		nonceChecked  = make([]bool, len(chain))
+		tstart        = time.Now()
+
+		nonceChecked = make([]bool, len(chain))
+		statedb      *state.StateDB
 	)
 
 	// Start the parallel nonce verifier.
 	nonceAbort, nonceResults := verifyNoncesFromBlocks(self.pow, chain)
 	defer close(nonceAbort)
 
+	txcount := 0
 	for i, block := range chain {
 		if atomic.LoadInt32(&self.procInterrupt) == 1 {
 			glog.V(logger.Debug).Infoln("Premature abort during block chain processing")
@@ -894,30 +886,29 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) {
 
 		// Create a new statedb using the parent block and report an
 		// error if it fails.
-		switch {
-		case i == 0:
-			err = self.stateCache.Reset(self.GetBlock(block.ParentHash()).Root())
-		default:
-			err = self.stateCache.Reset(chain[i-1].Root())
+		if statedb == nil {
+			statedb, err = state.New(self.GetBlock(block.ParentHash()).Root(), self.chainDb)
+		} else {
+			err = statedb.Reset(chain[i-1].Root())
 		}
 		if err != nil {
 			reportBlock(block, err)
 			return i, err
 		}
 		// Process block using the parent state as reference point.
-		receipts, logs, usedGas, err := self.processor.Process(block, self.stateCache, vm.Config{})
+		receipts, logs, usedGas, err := self.processor.Process(block, statedb, self.config.VmConfig)
 		if err != nil {
 			reportBlock(block, err)
 			return i, err
 		}
 		// Validate the state using the default validator
-		err = self.Validator().ValidateState(block, self.GetBlock(block.ParentHash()), self.stateCache, receipts, usedGas)
+		err = self.Validator().ValidateState(block, self.GetBlock(block.ParentHash()), statedb, receipts, usedGas)
 		if err != nil {
 			reportBlock(block, err)
 			return i, err
 		}
 		// Write state changes to database
-		_, err = self.stateCache.Commit(self.config.IsEIP158(block.Number()))
+		_, err = statedb.Commit()
 		if err != nil {
 			return i, err
 		}
@@ -929,6 +920,7 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) {
 			return i, err
 		}
 
+		txcount += len(block.Transactions())
 		// write the block to the chain and get the status
 		status, err := self.WriteBlock(block)
 		if err != nil {
@@ -963,54 +955,19 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) {
 		case SplitStatTy:
 			events = append(events, ChainSplitEvent{block, logs})
 		}
-
 		stats.processed++
-		if glog.V(logger.Info) {
-			stats.report(chain, i)
-		}
 	}
 
+	if (stats.queued > 0 || stats.processed > 0 || stats.ignored > 0) && bool(glog.V(logger.Info)) {
+		tend := time.Since(tstart)
+		start, end := chain[0], chain[len(chain)-1]
+		glog.Infof("imported %d block(s) (%d queued %d ignored) including %d txs in %v. #%v [%x / %x]\n", stats.processed, stats.queued, stats.ignored, txcount, tend, end.Number(), start.Hash().Bytes()[:4], end.Hash().Bytes()[:4])
+	}
 	go self.postChainEvents(events, coalescedLogs)
 
 	return 0, nil
 }
 
-// insertStats tracks and reports on block insertion.
-type insertStats struct {
-	queued, processed, ignored int
-	lastIndex                  int
-	startTime                  time.Time
-}
-
-const (
-	statsReportLimit     = 1024
-	statsReportTimeLimit = 8 * time.Second
-)
-
-// report prints statistics if some number of blocks have been processed
-// or more than a few seconds have passed since the last message.
-func (st *insertStats) report(chain []*types.Block, index int) {
-	limit := statsReportLimit
-	if index == len(chain)-1 {
-		limit = 0 // Always print a message for the last block.
-	}
-	now := time.Now()
-	duration := now.Sub(st.startTime)
-	if duration > statsReportTimeLimit || st.queued > limit || st.processed > limit || st.ignored > limit {
-		start, end := chain[st.lastIndex], chain[index]
-		txcount := countTransactions(chain[st.lastIndex : index+1])
-		glog.Infof("imported %d block(s) (%d queued %d ignored) including %d txs in %v. #%v [%x / %x]\n", st.processed, st.queued, st.ignored, txcount, duration, end.Number(), start.Hash().Bytes()[:4], end.Hash().Bytes()[:4])
-		*st = insertStats{startTime: now, lastIndex: index}
-	}
-}
-
-func countTransactions(chain []*types.Block) (c int) {
-	for _, b := range chain {
-		c += len(b.Transactions())
-	}
-	return c
-}
-
 // reorgs takes two blocks, an old chain and a new chain and will reconstruct the blocks and inserts them
 // to be part of the new canonical chain and accumulates potential missing transactions and post an
 // event about them
@@ -1260,4 +1217,4 @@ func (self *BlockChain) GetHeaderByNumber(number uint64) *types.Header {
 }
 
 // Config retrieves the blockchain's chain configuration.
-func (self *BlockChain) Config() *params.ChainConfig { return self.config }
+func (self *BlockChain) Config() *ChainConfig { return self.config }

core/blockchain_test.go

@@ -154,7 +154,7 @@ func testBlockChainImport(chain types.Blocks, blockchain *BlockChain) error {
 		blockchain.mu.Lock()
 		WriteTd(blockchain.chainDb, block.Hash(), new(big.Int).Add(block.Difficulty(), blockchain.GetTd(block.ParentHash())))
 		WriteBlock(blockchain.chainDb, block)
-		statedb.Commit(false)
+		statedb.Commit()
 		blockchain.mu.Unlock()
 	}
 	return nil
@@ -712,7 +712,7 @@ func TestFastVsFullChains(t *testing.T) {
 		funds    = big.NewInt(1000000000)
 		genesis  = GenesisBlockForTesting(gendb, address, funds)
 	)
-	blocks, receipts := GenerateChain(params.TestChainConfig, genesis, gendb, 1024, func(i int, block *BlockGen) {
+	blocks, receipts := GenerateChain(genesis, gendb, 1024, func(i int, block *BlockGen) {
 		block.SetCoinbase(common.Address{0x00})
 
 		// If the block number is multiple of 3, send a few bonus transactions to the miner
@@ -795,7 +795,7 @@ func TestLightVsFastVsFullChainHeads(t *testing.T) {
 		genesis  = GenesisBlockForTesting(gendb, address, funds)
 	)
 	height := uint64(1024)
-	blocks, receipts := GenerateChain(params.TestChainConfig, genesis, gendb, int(height), nil)
+	blocks, receipts := GenerateChain(genesis, gendb, int(height), nil)
 
 	// Configure a subchain to roll back
 	remove := []common.Hash{}
@@ -895,7 +895,7 @@ func TestChainTxReorgs(t *testing.T) {
 	//  - futureAdd: transaction added after the reorg has already finished
 	var pastAdd, freshAdd, futureAdd *types.Transaction
 
-	chain, _ := GenerateChain(params.TestChainConfig, genesis, db, 3, func(i int, gen *BlockGen) {
+	chain, _ := GenerateChain(genesis, db, 3, func(i int, gen *BlockGen) {
 		switch i {
 		case 0:
 			pastDrop, _ = types.NewTransaction(gen.TxNonce(addr2), addr2, big.NewInt(1000), params.TxGas, nil, nil).SignECDSA(key2)
@@ -920,7 +920,7 @@ func TestChainTxReorgs(t *testing.T) {
 	}
 
 	// overwrite the old chain
-	chain, _ = GenerateChain(params.TestChainConfig, genesis, db, 5, func(i int, gen *BlockGen) {
+	chain, _ = GenerateChain(genesis, db, 5, func(i int, gen *BlockGen) {
 		switch i {
 		case 0:
 			pastAdd, _ = types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), params.TxGas, nil, nil).SignECDSA(key3)
@@ -990,7 +990,7 @@ func TestLogReorgs(t *testing.T) {
 	blockchain, _ := NewBlockChain(db, testChainConfig(), FakePow{}, evmux)
 
 	subs := evmux.Subscribe(RemovedLogsEvent{})
-	chain, _ := GenerateChain(params.TestChainConfig, genesis, db, 2, func(i int, gen *BlockGen) {
+	chain, _ := GenerateChain(genesis, db, 2, func(i int, gen *BlockGen) {
 		if i == 1 {
 			tx, err := types.NewContractCreation(gen.TxNonce(addr1), new(big.Int), big.NewInt(1000000), new(big.Int), code).SignECDSA(key1)
 			if err != nil {
@@ -1003,7 +1003,7 @@ func TestLogReorgs(t *testing.T) {
 		t.Fatalf("failed to insert chain: %v", err)
 	}
 
-	chain, _ = GenerateChain(params.TestChainConfig, genesis, db, 3, func(i int, gen *BlockGen) {})
+	chain, _ = GenerateChain(genesis, db, 3, func(i int, gen *BlockGen) {})
 	if _, err := blockchain.InsertChain(chain); err != nil {
 		t.Fatalf("failed to insert forked chain: %v", err)
 	}
@@ -1025,12 +1025,12 @@ func TestReorgSideEvent(t *testing.T) {
 	evmux := &event.TypeMux{}
 	blockchain, _ := NewBlockChain(db, testChainConfig(), FakePow{}, evmux)
 
-	chain, _ := GenerateChain(params.TestChainConfig, genesis, db, 3, func(i int, gen *BlockGen) {})
+	chain, _ := GenerateChain(genesis, db, 3, func(i int, gen *BlockGen) {})
 	if _, err := blockchain.InsertChain(chain); err != nil {
 		t.Fatalf("failed to insert chain: %v", err)
 	}
 
-	replacementBlocks, _ := GenerateChain(params.TestChainConfig, genesis, db, 4, func(i int, gen *BlockGen) {
+	replacementBlocks, _ := GenerateChain(genesis, db, 4, func(i int, gen *BlockGen) {
 		tx, err := types.NewContractCreation(gen.TxNonce(addr1), new(big.Int), big.NewInt(1000000), new(big.Int), nil).SignECDSA(key1)
 		if i == 2 {
 			gen.OffsetTime(-1)
@@ -1090,144 +1090,3 @@ done:
 	}
 
 }
-
-// Tests if the canonical block can be fetched from the database during chain insertion.
-func TestCanonicalBlockRetrieval(t *testing.T) {
-	var (
-		db, _   = ethdb.NewMemDatabase()
-		genesis = WriteGenesisBlockForTesting(db)
-	)
-
-	evmux := &event.TypeMux{}
-	blockchain, _ := NewBlockChain(db, testChainConfig(), FakePow{}, evmux)
-
-	chain, _ := GenerateChain(params.TestChainConfig, genesis, db, 10, func(i int, gen *BlockGen) {})
-
-	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 {
-				ch := GetCanonicalHash(db, block.NumberU64())
-				if ch == (common.Hash{}) {
-					continue // busy wait for canonical hash to be written
-				}
-				if ch != block.Hash() {
-					t.Fatalf("unknown canonical hash, want %s, got %s", block.Hash().Hex(), ch.Hex())
-				}
-				fb := GetBlock(db, ch)
-				if fb == nil {
-					t.Fatalf("unable to retrieve block %d for canonical hash: %s", block.NumberU64(), ch.Hex())
-				}
-				if fb.Hash() != block.Hash() {
-					t.Fatalf("invalid block hash for block %d, want %s, got %s", block.NumberU64(), block.Hash().Hex(), fb.Hash().Hex())
-				}
-				return
-			}
-		}(chain[i])
-
-		blockchain.InsertChain(types.Blocks{chain[i]})
-	}
-}
-
-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)
-		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)
-	blocks, _ := GenerateChain(config, genesis, db, 4, func(i int, block *BlockGen) {
-		var (
-			tx      *types.Transaction
-			err     error
-			basicTx = func(signer types.Signer) (*types.Transaction, error) {
-				tx := types.NewTransaction(block.TxNonce(address), common.Address{}, new(big.Int), big.NewInt(21000), new(big.Int), nil)
-				tx.SetSigner(signer)
-				return tx.SignECDSA(key)
-			}
-		)
-		switch i {
-		case 0:
-			tx, err = basicTx(types.HomesteadSigner{})
-			if err != nil {
-				t.Fatal(err)
-			}
-			block.AddTx(tx)
-		case 2:
-			tx, err = basicTx(types.HomesteadSigner{})
-			if err != nil {
-				t.Fatal(err)
-			}
-			block.AddTx(tx)
-
-			tx, err = basicTx(types.NewEIP155Signer(config.ChainId))
-			if err != nil {
-				t.Fatal(err)
-			}
-			block.AddTx(tx)
-		case 3:
-			tx, err = basicTx(types.HomesteadSigner{})
-			if err != nil {
-				t.Fatal(err)
-			}
-			block.AddTx(tx)
-
-			tx, err = basicTx(types.NewEIP155Signer(config.ChainId))
-			if err != nil {
-				t.Fatal(err)
-			}
-			block.AddTx(tx)
-		}
-	})
-
-	if _, err := blockchain.InsertChain(blocks); err != nil {
-		t.Fatal(err)
-	}
-	block := blockchain.GetBlockByNumber(1)
-	if block.Transactions()[0].Protected() {
-		t.Error("Expected block[0].txs[0] to not be replay protected")
-	}
-
-	block = blockchain.GetBlockByNumber(3)
-	if block.Transactions()[0].Protected() {
-		t.Error("Expected block[3].txs[0] to not be replay protected")
-	}
-	if !block.Transactions()[1].Protected() {
-		t.Error("Expected block[3].txs[1] to be replay protected")
-	}
-	if _, err := blockchain.InsertChain(blocks[4:]); err != nil {
-		t.Fatal(err)
-	}
-
-	// generate an invalid chain id transaction
-	config = &params.ChainConfig{ChainId: big.NewInt(2), EIP155Block: big.NewInt(2), HomesteadBlock: new(big.Int)}
-	blocks, _ = GenerateChain(config, blocks[len(blocks)-1], db, 4, func(i int, block *BlockGen) {
-		var (
-			tx      *types.Transaction
-			err     error
-			basicTx = func(signer types.Signer) (*types.Transaction, error) {
-				tx := types.NewTransaction(block.TxNonce(address), common.Address{}, new(big.Int), big.NewInt(21000), new(big.Int), nil)
-				tx.SetSigner(signer)
-				return tx.SignECDSA(key)
-			}
-		)
-		switch i {
-		case 0:
-			tx, err = basicTx(types.NewEIP155Signer(big.NewInt(2)))
-			if err != nil {
-				t.Fatal(err)
-			}
-			block.AddTx(tx)
-		}
-	})
-	_, err := blockchain.InsertChain(blocks)
-	if err != types.ErrInvalidChainId {
-		t.Error("expected error:", types.ErrInvalidChainId)
-	}
-}

core/chain_makers.go

@@ -26,7 +26,6 @@ import (
 	"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"
 )
 
@@ -35,12 +34,8 @@ import (
  */
 
 // MakeChainConfig returns a new ChainConfig with the ethereum default chain settings.
-func MakeChainConfig() *params.ChainConfig {
-	return &params.ChainConfig{
-		HomesteadBlock: big.NewInt(0),
-		DAOForkBlock:   nil,
-		DAOForkSupport: true,
-	}
+func MakeChainConfig() *ChainConfig {
+	return &ChainConfig{HomesteadBlock: big.NewInt(0)}
 }
 
 // FakePow is a non-validating proof of work implementation.
@@ -73,8 +68,6 @@ type BlockGen struct {
 	txs      []*types.Transaction
 	receipts []*types.Receipt
 	uncles   []*types.Header
-
-	config *params.ChainConfig
 }
 
 // SetCoinbase sets the coinbase of the generated block.
@@ -108,7 +101,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(MakeChainConfig(), nil, b.gasPool, b.statedb, b.header, tx, b.header.GasUsed, vm.Config{})
 	if err != nil {
 		panic(err)
 	}
@@ -133,7 +126,7 @@ func (b *BlockGen) AddUncheckedReceipt(receipt *types.Receipt) {
 // TxNonce returns the next valid transaction nonce for the
 // account at addr. It panics if the account does not exist.
 func (b *BlockGen) TxNonce(addr common.Address) uint64 {
-	if !b.statedb.Exist(addr) {
+	if !b.statedb.HasAccount(addr) {
 		panic("account does not exist")
 	}
 	return b.statedb.GetNonce(addr)
@@ -180,32 +173,15 @@ func (b *BlockGen) OffsetTime(seconds int64) {
 // Blocks created by GenerateChain do not contain valid proof of work
 // values. Inserting them into BlockChain requires use of FakePow or
 // a similar non-validating proof of work implementation.
-func GenerateChain(config *params.ChainConfig, parent *types.Block, db ethdb.Database, n int, gen func(int, *BlockGen)) ([]*types.Block, []types.Receipts) {
+func GenerateChain(parent *types.Block, db ethdb.Database, n int, gen func(int, *BlockGen)) ([]*types.Block, []types.Receipts) {
 	blocks, receipts := make(types.Blocks, n), make([]types.Receipts, n)
 	genblock := func(i int, h *types.Header, statedb *state.StateDB) (*types.Block, types.Receipts) {
-		b := &BlockGen{parent: parent, i: i, chain: blocks, header: h, statedb: statedb, config: config}
-
-		// Mutate the state and block according to any hard-fork specs
-		if config == nil {
-			config = MakeChainConfig()
-		}
-		if daoBlock := config.DAOForkBlock; daoBlock != nil {
-			limit := new(big.Int).Add(daoBlock, params.DAOForkExtraRange)
-			if h.Number.Cmp(daoBlock) >= 0 && h.Number.Cmp(limit) < 0 {
-				if config.DAOForkSupport {
-					h.Extra = common.CopyBytes(params.DAOForkBlockExtra)
-				}
-			}
-		}
-		if config.DAOForkSupport && config.DAOForkBlock != nil && config.DAOForkBlock.Cmp(h.Number) == 0 {
-			ApplyDAOHardFork(statedb)
-		}
-		// Execute any user modifications to the block and finalize it
+		b := &BlockGen{parent: parent, i: i, chain: blocks, header: h, statedb: statedb}
 		if gen != nil {
 			gen(i, b)
 		}
 		AccumulateRewards(statedb, h, b.uncles)
-		root, err := statedb.Commit(config.IsEIP158(h.Number))
+		root, err := statedb.Commit()
 		if err != nil {
 			panic(fmt.Sprintf("state write error: %v", err))
 		}
@@ -217,7 +193,7 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, db ethdb.Dat
 		if err != nil {
 			panic(err)
 		}
-		header := makeHeader(config, parent, statedb)
+		header := makeHeader(parent, statedb)
 		block, receipt := genblock(i, header, statedb)
 		blocks[i] = block
 		receipts[i] = receipt
@@ -226,7 +202,7 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, db ethdb.Dat
 	return blocks, receipts
 }
 
-func makeHeader(config *params.ChainConfig, parent *types.Block, state *state.StateDB) *types.Header {
+func makeHeader(parent *types.Block, state *state.StateDB) *types.Header {
 	var time *big.Int
 	if parent.Time() == nil {
 		time = big.NewInt(10)
@@ -234,7 +210,7 @@ func makeHeader(config *params.ChainConfig, parent *types.Block, state *state.St
 		time = new(big.Int).Add(parent.Time(), big.NewInt(10)) // block time is fixed at 10 seconds
 	}
 	return &types.Header{
-		Root:       state.IntermediateRoot(config.IsEIP158(parent.Number())),
+		Root:       state.IntermediateRoot(),
 		ParentHash: parent.Hash(),
 		Coinbase:   parent.Coinbase(),
 		Difficulty: CalcDifficulty(MakeChainConfig(), time.Uint64(), new(big.Int).Sub(time, big.NewInt(10)).Uint64(), parent.Number(), parent.Difficulty()),
@@ -285,7 +261,7 @@ func makeHeaderChain(parent *types.Header, n int, db ethdb.Database, seed int) [
 
 // makeBlockChain creates a deterministic chain of blocks rooted at parent.
 func makeBlockChain(parent *types.Block, n int, db ethdb.Database, seed int) []*types.Block {
-	blocks, _ := GenerateChain(params.TestChainConfig, parent, db, n, func(i int, b *BlockGen) {
+	blocks, _ := GenerateChain(parent, db, n, func(i int, b *BlockGen) {
 		b.SetCoinbase(common.Address{0: byte(seed), 19: byte(i)})
 	})
 	return blocks

core/chain_makers_test.go

@@ -41,16 +41,13 @@ func ExampleGenerateChain() {
 		db, _   = ethdb.NewMemDatabase()
 	)
 
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-	}
 	// Ensure that key1 has some funds in the genesis block.
 	genesis := WriteGenesisBlockForTesting(db, GenesisAccount{addr1, big.NewInt(1000000)})
 
 	// This call generates a chain of 5 blocks. The function runs for
 	// each block and adds different features to gen based on the
 	// block index.
-	chain, _ := GenerateChain(chainConfig, genesis, db, 5, func(i int, gen *BlockGen) {
+	chain, _ := GenerateChain(genesis, db, 5, func(i int, gen *BlockGen) {
 		switch i {
 		case 0:
 			// In block 1, addr1 sends addr2 some ether.
@@ -80,9 +77,9 @@ func ExampleGenerateChain() {
 
 	// Import the chain. This runs all block validation rules.
 	evmux := &event.TypeMux{}
-	blockchain, _ := NewBlockChain(db, chainConfig, FakePow{}, evmux)
+	blockchain, _ := NewBlockChain(db, MakeChainConfig(), FakePow{}, evmux)
 	if i, err := blockchain.InsertChain(chain); err != nil {
-		fmt.Printf("insert error (block %d): %v\n", chain[i].NumberU64(), err)
+		fmt.Printf("insert error (block %d): %v\n", i, err)
 		return
 	}
 

core/chain_pow_test.go

@@ -25,7 +25,6 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/pow"
 )
 
@@ -61,7 +60,7 @@ func TestPowVerification(t *testing.T) {
 	var (
 		testdb, _ = ethdb.NewMemDatabase()
 		genesis   = GenesisBlockForTesting(testdb, common.Address{}, new(big.Int))
-		blocks, _ = GenerateChain(params.TestChainConfig, genesis, testdb, 8, nil)
+		blocks, _ = GenerateChain(genesis, testdb, 8, nil)
 	)
 	headers := make([]*types.Header, len(blocks))
 	for i, block := range blocks {
@@ -116,7 +115,7 @@ func testPowConcurrentVerification(t *testing.T, threads int) {
 	var (
 		testdb, _ = ethdb.NewMemDatabase()
 		genesis   = GenesisBlockForTesting(testdb, common.Address{}, new(big.Int))
-		blocks, _ = GenerateChain(params.TestChainConfig, genesis, testdb, 8, nil)
+		blocks, _ = GenerateChain(genesis, testdb, 8, nil)
 	)
 	headers := make([]*types.Header, len(blocks))
 	for i, block := range blocks {
@@ -187,7 +186,7 @@ func testPowConcurrentAbortion(t *testing.T, threads int) {
 	var (
 		testdb, _ = ethdb.NewMemDatabase()
 		genesis   = GenesisBlockForTesting(testdb, common.Address{}, new(big.Int))
-		blocks, _ = GenerateChain(params.TestChainConfig, genesis, testdb, 1024, nil)
+		blocks, _ = GenerateChain(genesis, testdb, 1024, nil)
 	)
 	headers := make([]*types.Header, len(blocks))
 	for i, block := range blocks {

core/config.go

@@ -0,0 +1,46 @@
+// 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 core
+
+import (
+	"errors"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/core/vm"
+)
+
+var ChainConfigNotFoundErr = errors.New("ChainConfig not found") // general config not found error
+
+// ChainConfig is the core config which determines the blockchain settings.
+//
+// ChainConfig is stored in the database on a per block basis. This means
+// that any network, identified by its genesis block, can have its own
+// set of configuration options.
+type ChainConfig struct {
+	HomesteadBlock *big.Int // homestead switch block
+
+	VmConfig vm.Config `json:"-"`
+}
+
+// IsHomestead returns whether num is either equal to the homestead block or greater.
+func (c *ChainConfig) IsHomestead(num *big.Int) bool {
+	if num == nil {
+		return false
+	}
+
+	return num.Cmp(c.HomesteadBlock) >= 0
+}

core/dao.go

@@ -1,74 +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 core
-
-import (
-	"bytes"
-	"math/big"
-
-	"github.com/ethereum/go-ethereum/core/state"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/params"
-)
-
-// ValidateDAOHeaderExtraData validates the extra-data field of a block header to
-// ensure it conforms to DAO hard-fork rules.
-//
-// DAO hard-fork extension to the header validity:
-//   a) if the node is no-fork, do not accept blocks in the [fork, fork+10) range
-//      with the fork specific extra-data set
-//   b) if the node is pro-fork, require blocks in the specific range to have the
-//      unique extra-data set.
-func ValidateDAOHeaderExtraData(config *params.ChainConfig, header *types.Header) error {
-	// Short circuit validation if the node doesn't care about the DAO fork
-	if config.DAOForkBlock == nil {
-		return nil
-	}
-	// Make sure the block is within the fork's modified extra-data range
-	limit := new(big.Int).Add(config.DAOForkBlock, params.DAOForkExtraRange)
-	if header.Number.Cmp(config.DAOForkBlock) < 0 || header.Number.Cmp(limit) >= 0 {
-		return nil
-	}
-	// Depending whether we support or oppose the fork, validate the extra-data contents
-	if config.DAOForkSupport {
-		if bytes.Compare(header.Extra, params.DAOForkBlockExtra) != 0 {
-			return ValidationError("DAO pro-fork bad block extra-data: 0x%x", header.Extra)
-		}
-	} else {
-		if bytes.Compare(header.Extra, params.DAOForkBlockExtra) == 0 {
-			return ValidationError("DAO no-fork bad block extra-data: 0x%x", header.Extra)
-		}
-	}
-	// All ok, header has the same extra-data we expect
-	return nil
-}
-
-// ApplyDAOHardFork modifies the state database according to the DAO hard-fork
-// rules, transferring all balances of a set of DAO accounts to a single refund
-// contract.
-func ApplyDAOHardFork(statedb *state.StateDB) {
-	// Retrieve the contract to refund balances into
-	refund := statedb.GetOrNewStateObject(params.DAORefundContract)
-
-	// Move every DAO account and extra-balance account funds into the refund contract
-	for _, addr := range params.DAODrainList {
-		if account := statedb.GetStateObject(addr); account != nil {
-			refund.AddBalance(account.Balance())
-			account.SetBalance(new(big.Int))
-		}
-	}
-}

core/dao_test.go

@@ -1,132 +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 core
-
-import (
-	"math/big"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/event"
-	"github.com/ethereum/go-ethereum/params"
-)
-
-// Tests that DAO-fork enabled clients can properly filter out fork-commencing
-// blocks based on their extradata fields.
-func TestDAOForkRangeExtradata(t *testing.T) {
-	forkBlock := big.NewInt(32)
-
-	// Generate a common prefix for both pro-forkers and non-forkers
-	db, _ := ethdb.NewMemDatabase()
-	genesis := WriteGenesisBlockForTesting(db)
-	prefix, _ := GenerateChain(params.TestChainConfig, genesis, db, int(forkBlock.Int64()-1), func(i int, gen *BlockGen) {})
-
-	// Create the concurrent, conflicting two nodes
-	proDb, _ := ethdb.NewMemDatabase()
-	WriteGenesisBlockForTesting(proDb)
-	proConf := &params.ChainConfig{HomesteadBlock: big.NewInt(0), DAOForkBlock: forkBlock, DAOForkSupport: true}
-	proBc, _ := NewBlockChain(proDb, proConf, new(FakePow), new(event.TypeMux))
-
-	conDb, _ := ethdb.NewMemDatabase()
-	WriteGenesisBlockForTesting(conDb)
-	conConf := &params.ChainConfig{HomesteadBlock: big.NewInt(0), DAOForkBlock: forkBlock, DAOForkSupport: false}
-	conBc, _ := NewBlockChain(conDb, conConf, new(FakePow), new(event.TypeMux))
-
-	if _, err := proBc.InsertChain(prefix); err != nil {
-		t.Fatalf("pro-fork: failed to import chain prefix: %v", err)
-	}
-	if _, err := conBc.InsertChain(prefix); err != nil {
-		t.Fatalf("con-fork: failed to import chain prefix: %v", err)
-	}
-	// Try to expand both pro-fork and non-fork chains iteratively with other camp's blocks
-	for i := int64(0); i < params.DAOForkExtraRange.Int64(); i++ {
-		// Create a pro-fork block, and try to feed into the no-fork chain
-		db, _ = ethdb.NewMemDatabase()
-		WriteGenesisBlockForTesting(db)
-		bc, _ := NewBlockChain(db, conConf, new(FakePow), new(event.TypeMux))
-
-		blocks := conBc.GetBlocksFromHash(conBc.CurrentBlock().Hash(), int(conBc.CurrentBlock().NumberU64()+1))
-		for j := 0; j < len(blocks)/2; j++ {
-			blocks[j], blocks[len(blocks)-1-j] = blocks[len(blocks)-1-j], blocks[j]
-		}
-		if _, err := bc.InsertChain(blocks); err != nil {
-			t.Fatalf("failed to import contra-fork chain for expansion: %v", err)
-		}
-		blocks, _ = GenerateChain(proConf, conBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {})
-		if _, err := conBc.InsertChain(blocks); err == nil {
-			t.Fatalf("contra-fork chain accepted pro-fork block: %v", blocks[0])
-		}
-		// Create a proper no-fork block for the contra-forker
-		blocks, _ = GenerateChain(conConf, conBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {})
-		if _, err := conBc.InsertChain(blocks); err != nil {
-			t.Fatalf("contra-fork chain didn't accepted no-fork block: %v", err)
-		}
-		// Create a no-fork block, and try to feed into the pro-fork chain
-		db, _ = ethdb.NewMemDatabase()
-		WriteGenesisBlockForTesting(db)
-		bc, _ = NewBlockChain(db, proConf, new(FakePow), new(event.TypeMux))
-
-		blocks = proBc.GetBlocksFromHash(proBc.CurrentBlock().Hash(), int(proBc.CurrentBlock().NumberU64()+1))
-		for j := 0; j < len(blocks)/2; j++ {
-			blocks[j], blocks[len(blocks)-1-j] = blocks[len(blocks)-1-j], blocks[j]
-		}
-		if _, err := bc.InsertChain(blocks); err != nil {
-			t.Fatalf("failed to import pro-fork chain for expansion: %v", err)
-		}
-		blocks, _ = GenerateChain(conConf, proBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {})
-		if _, err := proBc.InsertChain(blocks); err == nil {
-			t.Fatalf("pro-fork chain accepted contra-fork block: %v", blocks[0])
-		}
-		// Create a proper pro-fork block for the pro-forker
-		blocks, _ = GenerateChain(proConf, proBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {})
-		if _, err := proBc.InsertChain(blocks); err != nil {
-			t.Fatalf("pro-fork chain didn't accepted pro-fork block: %v", err)
-		}
-	}
-	// Verify that contra-forkers accept pro-fork extra-datas after forking finishes
-	db, _ = ethdb.NewMemDatabase()
-	WriteGenesisBlockForTesting(db)
-	bc, _ := NewBlockChain(db, conConf, new(FakePow), new(event.TypeMux))
-
-	blocks := conBc.GetBlocksFromHash(conBc.CurrentBlock().Hash(), int(conBc.CurrentBlock().NumberU64()+1))
-	for j := 0; j < len(blocks)/2; j++ {
-		blocks[j], blocks[len(blocks)-1-j] = blocks[len(blocks)-1-j], blocks[j]
-	}
-	if _, err := bc.InsertChain(blocks); err != nil {
-		t.Fatalf("failed to import contra-fork chain for expansion: %v", err)
-	}
-	blocks, _ = GenerateChain(proConf, conBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {})
-	if _, err := conBc.InsertChain(blocks); err != nil {
-		t.Fatalf("contra-fork chain didn't accept pro-fork block post-fork: %v", err)
-	}
-	// Verify that pro-forkers accept contra-fork extra-datas after forking finishes
-	db, _ = ethdb.NewMemDatabase()
-	WriteGenesisBlockForTesting(db)
-	bc, _ = NewBlockChain(db, proConf, new(FakePow), new(event.TypeMux))
-
-	blocks = proBc.GetBlocksFromHash(proBc.CurrentBlock().Hash(), int(proBc.CurrentBlock().NumberU64()+1))
-	for j := 0; j < len(blocks)/2; j++ {
-		blocks[j], blocks[len(blocks)-1-j] = blocks[len(blocks)-1-j], blocks[j]
-	}
-	if _, err := bc.InsertChain(blocks); err != nil {
-		t.Fatalf("failed to import pro-fork chain for expansion: %v", err)
-	}
-	blocks, _ = GenerateChain(conConf, proBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {})
-	if _, err := proBc.InsertChain(blocks); err != nil {
-		t.Fatalf("pro-fork chain didn't accept contra-fork block post-fork: %v", err)
-	}
-}

core/database_util.go

@@ -20,7 +20,6 @@ import (
 	"bytes"
 	"encoding/binary"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"math/big"
 
@@ -29,7 +28,6 @@ import (
 	"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"
 	"github.com/ethereum/go-ethereum/rlp"
 )
 
@@ -54,8 +52,7 @@ var (
 
 	blockHashPrefix = []byte("block-hash-") // [deprecated by the header/block split, remove eventually]
 
-	configPrefix           = []byte("ethereum-config-")          // config prefix for the db
-	ChainConfigNotFoundErr = errors.New("ChainConfig not found") // general config not found error
+	configPrefix = []byte("ethereum-config-") // config prefix for the db
 )
 
 // GetCanonicalHash retrieves a hash assigned to a canonical block number.
@@ -160,11 +157,7 @@ func GetTd(db ethdb.Database, hash common.Hash) *big.Int {
 }
 
 // GetBlock retrieves an entire block corresponding to the hash, assembling it
-// back from the stored header and body. If either the header or body could not
-// be retrieved nil is returned.
-//
-// Note, due to concurrent download of header and block body the header and thus
-// canonical hash can be stored in the database but the body data not (yet).
+// back from the stored header and body.
 func GetBlock(db ethdb.Database, hash common.Hash) *types.Block {
 	// Retrieve the block header and body contents
 	header := GetHeader(db, hash)
@@ -539,7 +532,7 @@ func WriteBlockChainVersion(db ethdb.Database, vsn int) {
 }
 
 // WriteChainConfig writes the chain config settings to the database.
-func WriteChainConfig(db ethdb.Database, hash common.Hash, cfg *params.ChainConfig) error {
+func WriteChainConfig(db ethdb.Database, hash common.Hash, cfg *ChainConfig) error {
 	// short circuit and ignore if nil config. GetChainConfig
 	// will return a default.
 	if cfg == nil {
@@ -555,13 +548,13 @@ func WriteChainConfig(db ethdb.Database, hash common.Hash, cfg *params.ChainConf
 }
 
 // GetChainConfig will fetch the network settings based on the given hash.
-func GetChainConfig(db ethdb.Database, hash common.Hash) (*params.ChainConfig, error) {
+func GetChainConfig(db ethdb.Database, hash common.Hash) (*ChainConfig, error) {
 	jsonChainConfig, _ := db.Get(append(configPrefix, hash[:]...))
 	if len(jsonChainConfig) == 0 {
 		return nil, ChainConfigNotFoundErr
 	}
 
-	var config params.ChainConfig
+	var config ChainConfig
 	if err := json.Unmarshal(jsonChainConfig, &config); err != nil {
 		return nil, err
 	}

core/database_util_test.go

@@ -30,7 +30,6 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/crypto/sha3"
 	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rlp"
 )
 
@@ -63,7 +62,7 @@ func (d *diffTest) UnmarshalJSON(b []byte) (err error) {
 	return nil
 }
 
-func TestCalcDifficulty(t *testing.T) {
+func TestDifficultyFrontier(t *testing.T) {
 	file, err := os.Open("../tests/files/BasicTests/difficulty.json")
 	if err != nil {
 		t.Fatal(err)
@@ -76,10 +75,9 @@ func TestCalcDifficulty(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	config := &params.ChainConfig{HomesteadBlock: big.NewInt(1150000)}
 	for name, test := range tests {
 		number := new(big.Int).Sub(test.CurrentBlocknumber, big.NewInt(1))
-		diff := CalcDifficulty(config, test.CurrentTimestamp, test.ParentTimestamp, number, test.ParentDifficulty)
+		diff := calcDifficultyFrontier(test.CurrentTimestamp, test.ParentTimestamp, number, test.ParentDifficulty)
 		if diff.Cmp(test.CurrentDifficulty) != 0 {
 			t.Error(name, "failed. Expected", test.CurrentDifficulty, "and calculated", diff)
 		}
@@ -563,7 +561,7 @@ func TestMipmapChain(t *testing.T) {
 	defer db.Close()
 
 	genesis := WriteGenesisBlockForTesting(db, GenesisAccount{addr, big.NewInt(1000000)})
-	chain, receipts := GenerateChain(params.TestChainConfig, genesis, db, 1010, func(i int, gen *BlockGen) {
+	chain, receipts := GenerateChain(genesis, db, 1010, func(i int, gen *BlockGen) {
 		var receipts types.Receipts
 		switch i {
 		case 1:

core/execution.go

@@ -27,14 +27,14 @@ import (
 
 // 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) {
-	ret, _, err = exec(true, env, caller, &addr, &addr, env.Db().GetCodeHash(addr), input, env.Db().GetCode(addr), gas, gasPrice, value)
+	ret, _, err = exec(env, caller, &addr, &addr, input, env.Db().GetCode(addr), gas, gasPrice, value)
 	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) {
 	callerAddr := caller.Address()
-	ret, _, err = exec(false, env, caller, &callerAddr, &addr, env.Db().GetCodeHash(addr), input, env.Db().GetCode(addr), gas, gasPrice, value)
+	ret, _, err = exec(env, caller, &callerAddr, &addr, input, env.Db().GetCode(addr), gas, gasPrice, value)
 	return ret, err
 }
 
@@ -43,13 +43,13 @@ func DelegateCall(env vm.Environment, caller vm.ContractRef, addr common.Address
 	callerAddr := caller.Address()
 	originAddr := env.Origin()
 	callerValue := caller.Value()
-	ret, _, err = execDelegateCall(env, caller, &originAddr, &callerAddr, &addr, env.Db().GetCodeHash(addr), input, env.Db().GetCode(addr), gas, gasPrice, callerValue)
+	ret, _, err = execDelegateCall(env, caller, &originAddr, &callerAddr, &addr, input, env.Db().GetCode(addr), gas, gasPrice, callerValue)
 	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) {
-	ret, address, err = exec(true, env, caller, nil, nil, crypto.Keccak256Hash(code), nil, code, gas, gasPrice, value)
+	ret, address, err = exec(env, caller, nil, nil, nil, code, gas, gasPrice, value)
 	// Here we get an error if we run into maximum stack depth,
 	// See: https://github.com/ethereum/yellowpaper/pull/131
 	// and YP definitions for CREATE instruction
@@ -59,7 +59,7 @@ func Create(env vm.Environment, caller vm.ContractRef, code []byte, gas, gasPric
 	return ret, address, err
 }
 
-func exec(transfers bool, env vm.Environment, caller vm.ContractRef, address, codeAddr *common.Address, codeHash common.Hash, input, code []byte, gas, gasPrice, value *big.Int) (ret []byte, addr common.Address, err error) {
+func exec(env vm.Environment, caller vm.ContractRef, address, codeAddr *common.Address, input, code []byte, gas, gasPrice, value *big.Int) (ret []byte, addr common.Address, err error) {
 	evm := env.Vm()
 	// Depth check execution. Fail if we're trying to execute above the
 	// limit.
@@ -85,37 +85,27 @@ func exec(transfers bool, env vm.Environment, caller vm.ContractRef, address, co
 		createAccount = true
 	}
 
-	snapshotPreTransfer := env.SnapshotDatabase()
+	snapshotPreTransfer := env.MakeSnapshot()
 	var (
 		from = env.Db().GetAccount(caller.Address())
 		to   vm.Account
 	)
 	if createAccount {
 		to = env.Db().CreateAccount(*address)
-		if env.ChainConfig().IsEIP158(env.BlockNumber()) {
-			env.Db().SetNonce(*address, 1)
-		}
 	} else {
 		if !env.Db().Exist(*address) {
-			if vm.Precompiled[address.Str()] == nil && env.ChainConfig().IsEIP158(env.BlockNumber()) && value.BitLen() == 0 {
-				caller.ReturnGas(gas, gasPrice)
-				return nil, common.Address{}, nil
-			}
-
 			to = env.Db().CreateAccount(*address)
 		} else {
 			to = env.Db().GetAccount(*address)
 		}
 	}
-	if transfers {
-		env.Transfer(from, to, value)
-	}
+	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(codeAddr, codeHash, code)
+	contract.SetCallCode(codeAddr, code)
 	defer contract.Finalise()
 
 	ret, err = evm.Run(contract, input)
@@ -136,16 +126,16 @@ func exec(transfers bool, env vm.Environment, caller vm.ContractRef, address, co
 	// 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 && (env.ChainConfig().IsHomestead(env.BlockNumber()) || err != vm.CodeStoreOutOfGasError) {
+	if err != nil && (env.RuleSet().IsHomestead(env.BlockNumber()) || err != vm.CodeStoreOutOfGasError) {
 		contract.UseGas(contract.Gas)
 
-		env.RevertToSnapshot(snapshotPreTransfer)
+		env.SetSnapshot(snapshotPreTransfer)
 	}
 
 	return ret, addr, err
 }
 
-func execDelegateCall(env vm.Environment, caller vm.ContractRef, originAddr, toAddr, codeAddr *common.Address, codeHash common.Hash, input, code []byte, gas, gasPrice, value *big.Int) (ret []byte, addr common.Address, err error) {
+func execDelegateCall(env vm.Environment, caller vm.ContractRef, originAddr, toAddr, codeAddr *common.Address, input, code []byte, gas, gasPrice, value *big.Int) (ret []byte, addr common.Address, err error) {
 	evm := env.Vm()
 	// Depth check execution. Fail if we're trying to execute above the
 	// limit.
@@ -154,7 +144,7 @@ func execDelegateCall(env vm.Environment, caller vm.ContractRef, originAddr, toA
 		return nil, common.Address{}, vm.DepthError
 	}
 
-	snapshot := env.SnapshotDatabase()
+	snapshot := env.MakeSnapshot()
 
 	var to vm.Account
 	if !env.Db().Exist(*toAddr) {
@@ -165,14 +155,14 @@ func execDelegateCall(env vm.Environment, caller vm.ContractRef, originAddr, toA
 
 	// Iinitialise a new contract and make initialise the delegate values
 	contract := vm.NewContract(caller, to, value, gas, gasPrice).AsDelegate()
-	contract.SetCallCode(codeAddr, codeHash, code)
+	contract.SetCallCode(codeAddr, code)
 	defer contract.Finalise()
 
 	ret, err = evm.Run(contract, input)
 	if err != nil {
 		contract.UseGas(contract.Gas)
 
-		env.RevertToSnapshot(snapshot)
+		env.SetSnapshot(snapshot)
 	}
 
 	return ret, addr, err

core/genesis.go

@@ -43,7 +43,7 @@ func WriteGenesisBlock(chainDb ethdb.Database, reader io.Reader) (*types.Block,
 	}
 
 	var genesis struct {
-		ChainConfig *params.ChainConfig `json:"config"`
+		ChainConfig *ChainConfig `json:"config"`
 		Nonce       string
 		Timestamp   string
 		ParentHash  string
@@ -73,7 +73,7 @@ func WriteGenesisBlock(chainDb ethdb.Database, reader io.Reader) (*types.Block,
 			statedb.SetState(address, common.HexToHash(key), common.HexToHash(value))
 		}
 	}
-	root, stateBatch := statedb.CommitBatch(false)
+	root, stateBatch := statedb.CommitBatch()
 
 	difficulty := common.String2Big(genesis.Difficulty)
 	block := types.NewBlock(&types.Header{
@@ -128,7 +128,7 @@ func GenesisBlockForTesting(db ethdb.Database, addr common.Address, balance *big
 	statedb, _ := state.New(common.Hash{}, db)
 	obj := statedb.GetOrNewStateObject(addr)
 	obj.SetBalance(balance)
-	root, err := statedb.Commit(false)
+	root, err := statedb.Commit()
 	if err != nil {
 		panic(fmt.Sprintf("cannot write state: %v", err))
 	}

core/headerchain.go

@@ -31,7 +31,6 @@ import (
 	"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"
 	"github.com/ethereum/go-ethereum/pow"
 	"github.com/hashicorp/golang-lru"
 )
@@ -42,7 +41,7 @@ import (
 // It is not thread safe either, the encapsulating chain structures should do
 // the necessary mutex locking/unlocking.
 type HeaderChain struct {
-	config *params.ChainConfig
+	config *ChainConfig
 
 	chainDb       ethdb.Database
 	genesisHeader *types.Header
@@ -66,7 +65,7 @@ type getHeaderValidatorFn func() HeaderValidator
 //  getValidator should return the parent's validator
 //  procInterrupt points to the parent's interrupt semaphore
 //  wg points to the parent's shutdown wait group
-func NewHeaderChain(chainDb ethdb.Database, config *params.ChainConfig, getValidator getHeaderValidatorFn, procInterrupt func() bool) (*HeaderChain, error) {
+func NewHeaderChain(chainDb ethdb.Database, config *ChainConfig, getValidator getHeaderValidatorFn, procInterrupt func() bool) (*HeaderChain, error) {
 	headerCache, _ := lru.New(headerCacheLimit)
 	tdCache, _ := lru.New(tdCacheLimit)
 
@@ -130,14 +129,6 @@ func (hc *HeaderChain) WriteHeader(header *types.Header) (status WriteStatus, er
 	localTd := hc.GetTd(hc.currentHeaderHash)
 	externTd := new(big.Int).Add(header.Difficulty, ptd)
 
-	// Irrelevant of the canonical status, write the td and header to the database
-	if err := hc.WriteTd(hash, externTd); err != nil {
-		glog.Fatalf("failed to write header total difficulty: %v", err)
-	}
-	if err := WriteHeader(hc.chainDb, header); err != nil {
-		glog.Fatalf("failed to write header contents: %v", err)
-	}
-
 	// If the total difficulty is higher than our known, add it to the canonical chain
 	// Second clause in the if statement reduces the vulnerability to selfish mining.
 	// Please refer to http://www.cs.cornell.edu/~ie53/publications/btcProcFC.pdf
@@ -159,7 +150,6 @@ func (hc *HeaderChain) WriteHeader(header *types.Header) (status WriteStatus, er
 			headHeader = hc.GetHeader(headHash)
 			headNumber = headHeader.Number.Uint64()
 		}
-
 		// Extend the canonical chain with the new header
 		if err := WriteCanonicalHash(hc.chainDb, hash, number); err != nil {
 			glog.Fatalf("failed to insert header number: %v", err)
@@ -167,13 +157,19 @@ func (hc *HeaderChain) WriteHeader(header *types.Header) (status WriteStatus, er
 		if err := WriteHeadHeaderHash(hc.chainDb, hash); err != nil {
 			glog.Fatalf("failed to insert head header hash: %v", err)
 		}
-
 		hc.currentHeaderHash, hc.currentHeader = hash, types.CopyHeader(header)
 
 		status = CanonStatTy
 	} else {
 		status = SideStatTy
 	}
+	// Irrelevant of the canonical status, write the header itself to the database
+	if err := hc.WriteTd(hash, externTd); err != nil {
+		glog.Fatalf("failed to write header total difficulty: %v", err)
+	}
+	if err := WriteHeader(hc.chainDb, header); err != nil {
+		glog.Fatalf("failed to write header contents: %v", err)
+	}
 	hc.headerCache.Add(hash, header)
 
 	return
@@ -444,13 +440,13 @@ func (hc *HeaderChain) SetGenesis(head *types.Header) {
 //
 // headerValidator implements HeaderValidator.
 type headerValidator struct {
-	config *params.ChainConfig
+	config *ChainConfig
 	hc     *HeaderChain // Canonical header chain
 	Pow    pow.PoW      // Proof of work used for validating
 }
 
 // NewBlockValidator returns a new block validator which is safe for re-use
-func NewHeaderValidator(config *params.ChainConfig, chain *HeaderChain, pow pow.PoW) HeaderValidator {
+func NewHeaderValidator(config *ChainConfig, chain *HeaderChain, pow pow.PoW) HeaderValidator {
 	return &headerValidator{
 		config: config,
 		Pow:    pow,

core/state/dump.go

@@ -21,10 +21,9 @@ import (
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/rlp"
 )
 
-type DumpAccount struct {
+type Account struct {
 	Balance  string            `json:"balance"`
 	Nonce    uint64            `json:"nonce"`
 	Root     string            `json:"root"`
@@ -33,41 +32,40 @@ type DumpAccount struct {
 	Storage  map[string]string `json:"storage"`
 }
 
-type Dump struct {
-	Root     string                 `json:"root"`
-	Accounts map[string]DumpAccount `json:"accounts"`
+type World struct {
+	Root     string             `json:"root"`
+	Accounts map[string]Account `json:"accounts"`
 }
 
-func (self *StateDB) RawDump() Dump {
-	dump := Dump{
+func (self *StateDB) RawDump() World {
+	world := World{
 		Root:     common.Bytes2Hex(self.trie.Root()),
-		Accounts: make(map[string]DumpAccount),
+		Accounts: make(map[string]Account),
 	}
 
 	it := self.trie.Iterator()
 	for it.Next() {
 		addr := self.trie.GetKey(it.Key)
-		var data Account
-		if err := rlp.DecodeBytes(it.Value, &data); err != nil {
+		stateObject, err := DecodeObject(common.BytesToAddress(addr), self.db, it.Value)
+		if err != nil {
 			panic(err)
 		}
 
-		obj := newObject(nil, common.BytesToAddress(addr), data, nil)
-		account := DumpAccount{
-			Balance:  data.Balance.String(),
-			Nonce:    data.Nonce,
-			Root:     common.Bytes2Hex(data.Root[:]),
-			CodeHash: common.Bytes2Hex(data.CodeHash),
-			Code:     common.Bytes2Hex(obj.Code(self.db)),
+		account := Account{
+			Balance:  stateObject.balance.String(),
+			Nonce:    stateObject.nonce,
+			Root:     common.Bytes2Hex(stateObject.Root()),
+			CodeHash: common.Bytes2Hex(stateObject.codeHash),
+			Code:     common.Bytes2Hex(stateObject.Code()),
 			Storage:  make(map[string]string),
 		}
-		storageIt := obj.getTrie(self.db).Iterator()
+		storageIt := stateObject.trie.Iterator()
 		for storageIt.Next() {
 			account.Storage[common.Bytes2Hex(self.trie.GetKey(storageIt.Key))] = common.Bytes2Hex(storageIt.Value)
 		}
-		dump.Accounts[common.Bytes2Hex(addr)] = account
+		world.Accounts[common.Bytes2Hex(addr)] = account
 	}
-	return dump
+	return world
 }
 
 func (self *StateDB) Dump() []byte {
@@ -78,3 +76,12 @@ func (self *StateDB) Dump() []byte {
 
 	return json
 }
+
+// Debug stuff
+func (self *StateObject) CreateOutputForDiff() {
+	fmt.Printf("%x %x %x %x\n", self.Address(), self.Root(), self.balance.Bytes(), self.nonce)
+	it := self.trie.Iterator()
+	for it.Next() {
+		fmt.Printf("%x %x\n", it.Key, it.Value)
+	}
+}

core/state/iterator.go

@@ -76,7 +76,7 @@ func (it *NodeIterator) step() error {
 	}
 	// Initialize the iterator if we've just started
 	if it.stateIt == nil {
-		it.stateIt = it.state.trie.NodeIterator()
+		it.stateIt = trie.NewNodeIterator(it.state.trie.Trie)
 	}
 	// If we had data nodes previously, we surely have at least state nodes
 	if it.dataIt != nil {

core/state/journal.go

@@ -1,117 +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 state
-
-import (
-	"math/big"
-
-	"github.com/ethereum/go-ethereum/common"
-)
-
-type journalEntry interface {
-	undo(*StateDB)
-}
-
-type journal []journalEntry
-
-type (
-	// Changes to the account trie.
-	createObjectChange struct {
-		account *common.Address
-	}
-	resetObjectChange struct {
-		prev *StateObject
-	}
-	suicideChange struct {
-		account     *common.Address
-		prev        bool // whether account had already suicided
-		prevbalance *big.Int
-	}
-
-	// Changes to individual accounts.
-	balanceChange struct {
-		account *common.Address
-		prev    *big.Int
-	}
-	nonceChange struct {
-		account *common.Address
-		prev    uint64
-	}
-	storageChange struct {
-		account       *common.Address
-		key, prevalue common.Hash
-	}
-	codeChange struct {
-		account            *common.Address
-		prevcode, prevhash []byte
-	}
-
-	// Changes to other state values.
-	refundChange struct {
-		prev *big.Int
-	}
-	addLogChange struct {
-		txhash common.Hash
-	}
-)
-
-func (ch createObjectChange) undo(s *StateDB) {
-	s.GetStateObject(*ch.account).deleted = true
-	delete(s.stateObjects, *ch.account)
-	delete(s.stateObjectsDirty, *ch.account)
-}
-
-func (ch resetObjectChange) undo(s *StateDB) {
-	s.setStateObject(ch.prev)
-}
-
-func (ch suicideChange) undo(s *StateDB) {
-	obj := s.GetStateObject(*ch.account)
-	if obj != nil {
-		obj.suicided = ch.prev
-		obj.setBalance(ch.prevbalance)
-	}
-}
-
-func (ch balanceChange) undo(s *StateDB) {
-	s.GetStateObject(*ch.account).setBalance(ch.prev)
-}
-
-func (ch nonceChange) undo(s *StateDB) {
-	s.GetStateObject(*ch.account).setNonce(ch.prev)
-}
-
-func (ch codeChange) undo(s *StateDB) {
-	s.GetStateObject(*ch.account).setCode(common.BytesToHash(ch.prevhash), ch.prevcode)
-}
-
-func (ch storageChange) undo(s *StateDB) {
-	s.GetStateObject(*ch.account).setState(ch.key, ch.prevalue)
-}
-
-func (ch refundChange) undo(s *StateDB) {
-	s.refund = ch.prev
-}
-
-func (ch addLogChange) undo(s *StateDB) {
-	logs := s.logs[ch.txhash]
-	if len(logs) == 1 {
-		delete(s.logs, ch.txhash)
-	} else {
-		s.logs[ch.txhash] = logs[:len(logs)-1]
-	}
-}

core/state/managed_state.go

@@ -33,14 +33,14 @@ type ManagedState struct {
 
 	mu sync.RWMutex
 
-	accounts map[common.Address]*account
+	accounts map[string]*account
 }
 
 // ManagedState returns a new managed state with the statedb as it's backing layer
 func ManageState(statedb *StateDB) *ManagedState {
 	return &ManagedState{
 		StateDB:  statedb.Copy(),
-		accounts: make(map[common.Address]*account),
+		accounts: make(map[string]*account),
 	}
 }
 
@@ -103,7 +103,7 @@ func (ms *ManagedState) SetNonce(addr common.Address, nonce uint64) {
 	so := ms.GetOrNewStateObject(addr)
 	so.SetNonce(nonce)
 
-	ms.accounts[addr] = newAccount(so)
+	ms.accounts[addr.Str()] = newAccount(so)
 }
 
 // HasAccount returns whether the given address is managed or not
@@ -114,28 +114,29 @@ func (ms *ManagedState) HasAccount(addr common.Address) bool {
 }
 
 func (ms *ManagedState) hasAccount(addr common.Address) bool {
-	_, ok := ms.accounts[addr]
+	_, ok := ms.accounts[addr.Str()]
 	return ok
 }
 
 // populate the managed state
 func (ms *ManagedState) getAccount(addr common.Address) *account {
-	if account, ok := ms.accounts[addr]; !ok {
+	straddr := addr.Str()
+	if account, ok := ms.accounts[straddr]; !ok {
 		so := ms.GetOrNewStateObject(addr)
-		ms.accounts[addr] = newAccount(so)
+		ms.accounts[straddr] = newAccount(so)
 	} else {
 		// Always make sure the state account nonce isn't actually higher
 		// than the tracked one.
 		so := ms.StateDB.GetStateObject(addr)
-		if so != nil && uint64(len(account.nonces))+account.nstart < so.Nonce() {
-			ms.accounts[addr] = newAccount(so)
+		if so != nil && uint64(len(account.nonces))+account.nstart < so.nonce {
+			ms.accounts[straddr] = newAccount(so)
 		}
 
 	}
 
-	return ms.accounts[addr]
+	return ms.accounts[straddr]
 }
 
 func newAccount(so *StateObject) *account {
-	return &account{so, so.Nonce(), nil}
+	return &account{so, so.nonce, nil}
 }

core/state/managed_state_test.go

@@ -29,9 +29,11 @@ func create() (*ManagedState, *account) {
 	db, _ := ethdb.NewMemDatabase()
 	statedb, _ := New(common.Hash{}, db)
 	ms := ManageState(statedb)
-	ms.StateDB.SetNonce(addr, 100)
-	ms.accounts[addr] = newAccount(ms.StateDB.GetStateObject(addr))
-	return ms, ms.accounts[addr]
+	so := &StateObject{address: addr, nonce: 100}
+	ms.StateDB.stateObjects[addr.Str()] = so
+	ms.accounts[addr.Str()] = newAccount(so)
+
+	return ms, ms.accounts[addr.Str()]
 }
 
 func TestNewNonce(t *testing.T) {
@@ -90,7 +92,7 @@ func TestRemoteNonceChange(t *testing.T) {
 	account.nonces = append(account.nonces, nn...)
 	nonce := ms.NewNonce(addr)
 
-	ms.StateDB.stateObjects[addr].data.Nonce = 200
+	ms.StateDB.stateObjects[addr.Str()].nonce = 200
 	nonce = ms.NewNonce(addr)
 	if nonce != 200 {
 		t.Error("expected nonce after remote update to be", 201, "got", nonce)
@@ -98,7 +100,7 @@ func TestRemoteNonceChange(t *testing.T) {
 	ms.NewNonce(addr)
 	ms.NewNonce(addr)
 	ms.NewNonce(addr)
-	ms.StateDB.stateObjects[addr].data.Nonce = 200
+	ms.StateDB.stateObjects[addr.Str()].nonce = 200
 	nonce = ms.NewNonce(addr)
 	if nonce != 204 {
 		t.Error("expected nonce after remote update to be", 201, "got", nonce)

core/state/state_object.go

@@ -57,231 +57,143 @@ func (self Storage) Copy() Storage {
 	return cpy
 }
 
-// StateObject represents an Ethereum account which is being modified.
-//
-// The usage pattern is as follows:
-// First you need to obtain a state object.
-// Account values can be accessed and modified through the object.
-// Finally, call CommitTrie to write the modified storage trie into a database.
 type StateObject struct {
-	address common.Address // Ethereum address of this account
-	data    Account
-	db      *StateDB
+	db   trie.Database // State database for storing state changes
+	trie *trie.SecureTrie
 
-	// DB error.
-	// State objects are used by the consensus core and VM which are
-	// unable to deal with database-level errors. Any error that occurs
-	// during a database read is memoized here and will eventually be returned
-	// by StateDB.Commit.
-	dbErr error
+	// Address belonging to this account
+	address common.Address
+	// The balance of the account
+	balance *big.Int
+	// The nonce of the account
+	nonce uint64
+	// The code hash if code is present (i.e. a contract)
+	codeHash []byte
+	// The code for this account
+	code Code
+	// Temporarily initialisation code
+	initCode Code
+	// Cached storage (flushed when updated)
+	storage Storage
 
-	// Write caches.
-	trie *trie.SecureTrie // storage trie, which becomes non-nil on first access
-	code Code             // contract bytecode, which gets set when code is loaded
-
-	cachedStorage Storage // Storage entry cache to avoid duplicate reads
-	dirtyStorage  Storage // Storage entries that need to be flushed to disk
-
-	// Cache flags.
-	// When an object is marked suicided it will be delete from the trie
-	// during the "update" phase of the state transition.
-	dirtyCode bool // true if the code was updated
-	suicided  bool
-	deleted   bool
-	onDirty   func(addr common.Address) // Callback method to mark a state object newly dirty
+	// Mark for deletion
+	// When an object is marked for deletion it will be delete from the trie
+	// during the "update" phase of the state transition
+	remove  bool
+	deleted bool
+	dirty   bool
 }
 
-// empty returns whether the account is considered empty.
-func (s *StateObject) empty() bool {
-	return s.data.Nonce == 0 && s.data.Balance.BitLen() == 0 && bytes.Equal(s.data.CodeHash, emptyCodeHash)
-}
-
-// Account is the Ethereum consensus representation of accounts.
-// These objects are stored in the main account trie.
-type Account struct {
-	Nonce    uint64
-	Balance  *big.Int
-	Root     common.Hash // merkle root of the storage trie
-	CodeHash []byte
-}
-
-// newObject creates a state object.
-func newObject(db *StateDB, address common.Address, data Account, onDirty func(addr common.Address)) *StateObject {
-	if data.Balance == nil {
-		data.Balance = new(big.Int)
+func NewStateObject(address common.Address, db trie.Database) *StateObject {
+	object := &StateObject{
+		db:       db,
+		address:  address,
+		balance:  new(big.Int),
+		dirty:    true,
+		codeHash: emptyCodeHash,
+		storage:  make(Storage),
 	}
-	if data.CodeHash == nil {
-		data.CodeHash = emptyCodeHash
-	}
-	return &StateObject{db: db, address: address, data: data, cachedStorage: make(Storage), dirtyStorage: make(Storage), onDirty: onDirty}
+	object.trie, _ = trie.NewSecure(common.Hash{}, db)
+	return object
 }
 
-// EncodeRLP implements rlp.Encoder.
-func (c *StateObject) EncodeRLP(w io.Writer) error {
-	return rlp.Encode(w, c.data)
-}
+func (self *StateObject) MarkForDeletion() {
+	self.remove = true
+	self.dirty = true
 
-// setError remembers the first non-nil error it is called with.
-func (self *StateObject) setError(err error) {
-	if self.dbErr == nil {
-		self.dbErr = err
-	}
-}
-
-func (self *StateObject) markSuicided() {
-	self.suicided = true
-	if self.onDirty != nil {
-		self.onDirty(self.Address())
-		self.onDirty = nil
-	}
 	if glog.V(logger.Core) {
-		glog.Infof("%x: #%d %v X\n", self.Address(), self.Nonce(), self.Balance())
+		glog.Infof("%x: #%d %v X\n", self.Address(), self.nonce, self.balance)
 	}
 }
 
-func (c *StateObject) getTrie(db trie.Database) *trie.SecureTrie {
-	if c.trie == nil {
-		var err error
-		c.trie, err = trie.NewSecure(c.data.Root, db, 0)
-		if err != nil {
-			c.trie, _ = trie.NewSecure(common.Hash{}, db, 0)
-			c.setError(fmt.Errorf("can't create storage trie: %v", err))
-		}
-	}
-	return c.trie
+func (c *StateObject) getAddr(addr common.Hash) common.Hash {
+	var ret []byte
+	rlp.DecodeBytes(c.trie.Get(addr[:]), &ret)
+	return common.BytesToHash(ret)
 }
 
-// GetState returns a value in account storage.
-func (self *StateObject) GetState(db trie.Database, key common.Hash) common.Hash {
-	value, exists := self.cachedStorage[key]
-	if exists {
-		return value
+func (c *StateObject) setAddr(addr, value common.Hash) {
+	v, err := rlp.EncodeToBytes(bytes.TrimLeft(value[:], "\x00"))
+	if err != nil {
+		// if RLPing failed we better panic and not fail silently. This would be considered a consensus issue
+		panic(err)
 	}
-	// Load from DB in case it is missing.
-	if enc := self.getTrie(db).Get(key[:]); len(enc) > 0 {
-		_, content, _, err := rlp.Split(enc)
-		if err != nil {
-			self.setError(err)
+	c.trie.Update(addr[:], v)
+}
+
+func (self *StateObject) Storage() Storage {
+	return self.storage
+}
+
+func (self *StateObject) GetState(key common.Hash) common.Hash {
+	value, exists := self.storage[key]
+	if !exists {
+		value = self.getAddr(key)
+		if (value != common.Hash{}) {
+			self.storage[key] = value
 		}
-		value.SetBytes(content)
-	}
-	if (value != common.Hash{}) {
-		self.cachedStorage[key] = value
 	}
+
 	return value
 }
 
-// SetState updates a value in account storage.
-func (self *StateObject) SetState(db trie.Database, key, value common.Hash) {
-	self.db.journal = append(self.db.journal, storageChange{
-		account:  &self.address,
-		key:      key,
-		prevalue: self.GetState(db, key),
-	})
-	self.setState(key, value)
+func (self *StateObject) SetState(key, value common.Hash) {
+	self.storage[key] = value
+	self.dirty = true
 }
 
-func (self *StateObject) setState(key, value common.Hash) {
-	self.cachedStorage[key] = value
-	self.dirtyStorage[key] = value
-
-	if self.onDirty != nil {
-		self.onDirty(self.Address())
-		self.onDirty = nil
-	}
-}
-
-// updateTrie writes cached storage modifications into the object's storage trie.
-func (self *StateObject) updateTrie(db trie.Database) {
-	tr := self.getTrie(db)
-	for key, value := range self.dirtyStorage {
-		delete(self.dirtyStorage, key)
+// Update updates the current cached storage to the trie
+func (self *StateObject) Update() {
+	for key, value := range self.storage {
 		if (value == common.Hash{}) {
-			tr.Delete(key[:])
+			self.trie.Delete(key[:])
 			continue
 		}
-		// Encoding []byte cannot fail, ok to ignore the error.
-		v, _ := rlp.EncodeToBytes(bytes.TrimLeft(value[:], "\x00"))
-		tr.Update(key[:], v)
+		self.setAddr(key, value)
 	}
 }
 
-// UpdateRoot sets the trie root to the current root hash of
-func (self *StateObject) updateRoot(db trie.Database) {
-	self.updateTrie(db)
-	self.data.Root = self.trie.Hash()
-}
-
-// CommitTrie the storage trie of the object to dwb.
-// This updates the trie root.
-func (self *StateObject) CommitTrie(db trie.Database, dbw trie.DatabaseWriter) error {
-	self.updateTrie(db)
-	if self.dbErr != nil {
-		return self.dbErr
-	}
-	root, err := self.trie.CommitTo(dbw)
-	if err == nil {
-		self.data.Root = root
-	}
-	return err
-}
-
-// AddBalance removes amount from c's balance.
-// It is used to add funds to the destination account of a transfer.
 func (c *StateObject) AddBalance(amount *big.Int) {
-	// EIP158: We must check emptiness for the objects such that the account
-	// clearing (0,0,0 objects) can take effect.
-	if amount.Cmp(common.Big0) == 0 && !c.empty() {
-		return
-	}
-	c.SetBalance(new(big.Int).Add(c.Balance(), amount))
+	c.SetBalance(new(big.Int).Add(c.balance, amount))
 
 	if glog.V(logger.Core) {
-		glog.Infof("%x: #%d %v (+ %v)\n", c.Address(), c.Nonce(), c.Balance(), amount)
+		glog.Infof("%x: #%d %v (+ %v)\n", c.Address(), c.nonce, c.balance, amount)
 	}
 }
 
-// SubBalance removes amount from c's balance.
-// It is used to remove funds from the origin account of a transfer.
 func (c *StateObject) SubBalance(amount *big.Int) {
-	if amount.Cmp(common.Big0) == 0 {
-		return
-	}
-	c.SetBalance(new(big.Int).Sub(c.Balance(), amount))
+	c.SetBalance(new(big.Int).Sub(c.balance, amount))
 
 	if glog.V(logger.Core) {
-		glog.Infof("%x: #%d %v (- %v)\n", c.Address(), c.Nonce(), c.Balance(), amount)
+		glog.Infof("%x: #%d %v (- %v)\n", c.Address(), c.nonce, c.balance, amount)
 	}
 }
 
-func (self *StateObject) SetBalance(amount *big.Int) {
-	self.db.journal = append(self.db.journal, balanceChange{
-		account: &self.address,
-		prev:    new(big.Int).Set(self.data.Balance),
-	})
-	self.setBalance(amount)
+func (c *StateObject) SetBalance(amount *big.Int) {
+	c.balance = amount
+	c.dirty = true
 }
 
-func (self *StateObject) setBalance(amount *big.Int) {
-	self.data.Balance = amount
-	if self.onDirty != nil {
-		self.onDirty(self.Address())
-		self.onDirty = nil
-	}
+func (c *StateObject) St() Storage {
+	return c.storage
 }
 
 // Return the gas back to the origin. Used by the Virtual machine or Closures
 func (c *StateObject) ReturnGas(gas, price *big.Int) {}
 
-func (self *StateObject) deepCopy(db *StateDB, onDirty func(addr common.Address)) *StateObject {
-	stateObject := newObject(db, self.address, self.data, onDirty)
+func (self *StateObject) Copy() *StateObject {
+	stateObject := NewStateObject(self.Address(), self.db)
+	stateObject.balance.Set(self.balance)
+	stateObject.codeHash = common.CopyBytes(self.codeHash)
+	stateObject.nonce = self.nonce
 	stateObject.trie = self.trie
-	stateObject.code = self.code
-	stateObject.dirtyStorage = self.dirtyStorage.Copy()
-	stateObject.cachedStorage = self.dirtyStorage.Copy()
-	stateObject.suicided = self.suicided
-	stateObject.dirtyCode = self.dirtyCode
+	stateObject.code = common.CopyBytes(self.code)
+	stateObject.initCode = common.CopyBytes(self.initCode)
+	stateObject.storage = self.storage.Copy()
+	stateObject.remove = self.remove
+	stateObject.dirty = self.dirty
 	stateObject.deleted = self.deleted
+
 	return stateObject
 }
 
@@ -289,73 +201,40 @@ func (self *StateObject) deepCopy(db *StateDB, onDirty func(addr common.Address)
 // Attribute accessors
 //
 
+func (self *StateObject) Balance() *big.Int {
+	return self.balance
+}
+
 // Returns the address of the contract/account
 func (c *StateObject) Address() common.Address {
 	return c.address
 }
 
-// Code returns the contract code associated with this object, if any.
-func (self *StateObject) Code(db trie.Database) []byte {
-	if self.code != nil {
-		return self.code
-	}
-	if bytes.Equal(self.CodeHash(), emptyCodeHash) {
-		return nil
-	}
-	code, err := db.Get(self.CodeHash())
-	if err != nil {
-		self.setError(fmt.Errorf("can't load code hash %x: %v", self.CodeHash(), err))
-	}
-	self.code = code
-	return code
+func (self *StateObject) Trie() *trie.SecureTrie {
+	return self.trie
 }
 
-func (self *StateObject) SetCode(codeHash common.Hash, code []byte) {
-	prevcode := self.Code(self.db.db)
-	self.db.journal = append(self.db.journal, codeChange{
-		account:  &self.address,
-		prevhash: self.CodeHash(),
-		prevcode: prevcode,
-	})
-	self.setCode(codeHash, code)
+func (self *StateObject) Root() []byte {
+	return self.trie.Root()
 }
 
-func (self *StateObject) setCode(codeHash common.Hash, code []byte) {
+func (self *StateObject) Code() []byte {
+	return self.code
+}
+
+func (self *StateObject) SetCode(code []byte) {
 	self.code = code
-	self.data.CodeHash = codeHash[:]
-	self.dirtyCode = true
-	if self.onDirty != nil {
-		self.onDirty(self.Address())
-		self.onDirty = nil
-	}
+	self.codeHash = crypto.Keccak256(code)
+	self.dirty = true
 }
 
 func (self *StateObject) SetNonce(nonce uint64) {
-	self.db.journal = append(self.db.journal, nonceChange{
-		account: &self.address,
-		prev:    self.data.Nonce,
-	})
-	self.setNonce(nonce)
-}
-
-func (self *StateObject) setNonce(nonce uint64) {
-	self.data.Nonce = nonce
-	if self.onDirty != nil {
-		self.onDirty(self.Address())
-		self.onDirty = nil
-	}
-}
-
-func (self *StateObject) CodeHash() []byte {
-	return self.data.CodeHash
-}
-
-func (self *StateObject) Balance() *big.Int {
-	return self.data.Balance
+	self.nonce = nonce
+	self.dirty = true
 }
 
 func (self *StateObject) Nonce() uint64 {
-	return self.data.Nonce
+	return self.nonce
 }
 
 // Never called, but must be present to allow StateObject to be used
@@ -367,16 +246,52 @@ func (self *StateObject) Value() *big.Int {
 
 func (self *StateObject) ForEachStorage(cb func(key, value common.Hash) bool) {
 	// When iterating over the storage check the cache first
-	for h, value := range self.cachedStorage {
+	for h, value := range self.storage {
 		cb(h, value)
 	}
 
-	it := self.getTrie(self.db.db).Iterator()
+	it := self.trie.Iterator()
 	for it.Next() {
 		// ignore cached values
 		key := common.BytesToHash(self.trie.GetKey(it.Key))
-		if _, ok := self.cachedStorage[key]; !ok {
+		if _, ok := self.storage[key]; !ok {
 			cb(key, common.BytesToHash(it.Value))
 		}
 	}
 }
+
+type extStateObject struct {
+	Nonce    uint64
+	Balance  *big.Int
+	Root     common.Hash
+	CodeHash []byte
+}
+
+// EncodeRLP implements rlp.Encoder.
+func (c *StateObject) EncodeRLP(w io.Writer) error {
+	return rlp.Encode(w, []interface{}{c.nonce, c.balance, c.Root(), c.codeHash})
+}
+
+// DecodeObject decodes an RLP-encoded state object.
+func DecodeObject(address common.Address, db trie.Database, data []byte) (*StateObject, error) {
+	var (
+		obj = &StateObject{address: address, db: db, storage: make(Storage)}
+		ext extStateObject
+		err error
+	)
+	if err = rlp.DecodeBytes(data, &ext); err != nil {
+		return nil, err
+	}
+	if obj.trie, err = trie.NewSecure(ext.Root, db); err != nil {
+		return nil, err
+	}
+	if !bytes.Equal(ext.CodeHash, emptyCodeHash) {
+		if obj.code, err = db.Get(ext.CodeHash); err != nil {
+			return nil, fmt.Errorf("can't get code for hash %x: %v", ext.CodeHash, err)
+		}
+	}
+	obj.nonce = ext.Nonce
+	obj.balance = ext.Balance
+	obj.codeHash = ext.CodeHash
+	return obj, nil
+}

core/state/state_test.go

@@ -24,7 +24,6 @@ import (
 	checker "gopkg.in/check.v1"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethdb"
 )
 
@@ -41,14 +40,14 @@ func (s *StateSuite) TestDump(c *checker.C) {
 	obj1 := s.state.GetOrNewStateObject(toAddr([]byte{0x01}))
 	obj1.AddBalance(big.NewInt(22))
 	obj2 := s.state.GetOrNewStateObject(toAddr([]byte{0x01, 0x02}))
-	obj2.SetCode(crypto.Keccak256Hash([]byte{3, 3, 3, 3, 3, 3, 3}), []byte{3, 3, 3, 3, 3, 3, 3})
+	obj2.SetCode([]byte{3, 3, 3, 3, 3, 3, 3})
 	obj3 := s.state.GetOrNewStateObject(toAddr([]byte{0x02}))
 	obj3.SetBalance(big.NewInt(44))
 
 	// write some of them to the trie
-	s.state.updateStateObject(obj1)
-	s.state.updateStateObject(obj2)
-	s.state.Commit(false)
+	s.state.UpdateStateObject(obj1)
+	s.state.UpdateStateObject(obj2)
+	s.state.Commit()
 
 	// check that dump contains the state objects that are in trie
 	got := string(s.state.Dump())
@@ -100,7 +99,7 @@ func TestNull(t *testing.T) {
 	//value := common.FromHex("0x823140710bf13990e4500136726d8b55")
 	var value common.Hash
 	state.SetState(address, common.Hash{}, value)
-	state.Commit(false)
+	state.Commit()
 	value = state.GetState(address, common.Hash{})
 	if !common.EmptyHash(value) {
 		t.Errorf("expected empty hash. got %x", value)
@@ -116,12 +115,12 @@ func (s *StateSuite) TestSnapshot(c *checker.C) {
 	// set initial state object value
 	s.state.SetState(stateobjaddr, storageaddr, data1)
 	// get snapshot of current state
-	snapshot := s.state.Snapshot()
+	snapshot := s.state.Copy()
 
 	// set new state object value
 	s.state.SetState(stateobjaddr, storageaddr, data2)
 	// restore snapshot
-	s.state.RevertToSnapshot(snapshot)
+	s.state.Set(snapshot)
 
 	// get state storage value
 	res := s.state.GetState(stateobjaddr, storageaddr)
@@ -129,12 +128,6 @@ func (s *StateSuite) TestSnapshot(c *checker.C) {
 	c.Assert(data1, checker.DeepEquals, res)
 }
 
-func TestSnapshotEmpty(t *testing.T) {
-	db, _ := ethdb.NewMemDatabase()
-	state, _ := New(common.Hash{}, db)
-	state.RevertToSnapshot(state.Snapshot())
-}
-
 // use testing instead of checker because checker does not support
 // printing/logging in tests (-check.vv does not work)
 func TestSnapshot2(t *testing.T) {
@@ -153,85 +146,80 @@ func TestSnapshot2(t *testing.T) {
 
 	// db, trie are already non-empty values
 	so0 := state.GetStateObject(stateobjaddr0)
-	so0.SetBalance(big.NewInt(42))
-	so0.SetNonce(43)
-	so0.SetCode(crypto.Keccak256Hash([]byte{'c', 'a', 'f', 'e'}), []byte{'c', 'a', 'f', 'e'})
-	so0.suicided = false
+	so0.balance = big.NewInt(42)
+	so0.nonce = 43
+	so0.SetCode([]byte{'c', 'a', 'f', 'e'})
+	so0.remove = true
 	so0.deleted = false
-	state.setStateObject(so0)
-
-	root, _ := state.Commit(false)
-	state.Reset(root)
+	so0.dirty = false
+	state.SetStateObject(so0)
 
 	// and one with deleted == true
 	so1 := state.GetStateObject(stateobjaddr1)
-	so1.SetBalance(big.NewInt(52))
-	so1.SetNonce(53)
-	so1.SetCode(crypto.Keccak256Hash([]byte{'c', 'a', 'f', 'e', '2'}), []byte{'c', 'a', 'f', 'e', '2'})
-	so1.suicided = true
+	so1.balance = big.NewInt(52)
+	so1.nonce = 53
+	so1.SetCode([]byte{'c', 'a', 'f', 'e', '2'})
+	so1.remove = true
 	so1.deleted = true
-	state.setStateObject(so1)
+	so1.dirty = true
+	state.SetStateObject(so1)
 
 	so1 = state.GetStateObject(stateobjaddr1)
 	if so1 != nil {
 		t.Fatalf("deleted object not nil when getting")
 	}
 
-	snapshot := state.Snapshot()
-	state.RevertToSnapshot(snapshot)
+	snapshot := state.Copy()
+	state.Set(snapshot)
 
 	so0Restored := state.GetStateObject(stateobjaddr0)
-	// Update lazily-loaded values before comparing.
-	so0Restored.GetState(db, storageaddr)
-	so0Restored.Code(db)
+	so1Restored := state.GetStateObject(stateobjaddr1)
 	// non-deleted is equal (restored)
 	compareStateObjects(so0Restored, so0, t)
-
 	// deleted should be nil, both before and after restore of state copy
-	so1Restored := state.GetStateObject(stateobjaddr1)
 	if so1Restored != nil {
-		t.Fatalf("deleted object not nil after restoring snapshot: %+v", so1Restored)
+		t.Fatalf("deleted object not nil after restoring snapshot")
 	}
 }
 
 func compareStateObjects(so0, so1 *StateObject, t *testing.T) {
-	if so0.Address() != so1.Address() {
+	if so0.address != so1.address {
 		t.Fatalf("Address mismatch: have %v, want %v", so0.address, so1.address)
 	}
-	if so0.Balance().Cmp(so1.Balance()) != 0 {
-		t.Fatalf("Balance mismatch: have %v, want %v", so0.Balance(), so1.Balance())
+	if so0.balance.Cmp(so1.balance) != 0 {
+		t.Fatalf("Balance mismatch: have %v, want %v", so0.balance, so1.balance)
 	}
-	if so0.Nonce() != so1.Nonce() {
-		t.Fatalf("Nonce mismatch: have %v, want %v", so0.Nonce(), so1.Nonce())
+	if so0.nonce != so1.nonce {
+		t.Fatalf("Nonce mismatch: have %v, want %v", so0.nonce, so1.nonce)
 	}
-	if so0.data.Root != so1.data.Root {
-		t.Errorf("Root mismatch: have %x, want %x", so0.data.Root[:], so1.data.Root[:])
-	}
-	if !bytes.Equal(so0.CodeHash(), so1.CodeHash()) {
-		t.Fatalf("CodeHash mismatch: have %v, want %v", so0.CodeHash(), so1.CodeHash())
+	if !bytes.Equal(so0.codeHash, so1.codeHash) {
+		t.Fatalf("CodeHash mismatch: have %v, want %v", so0.codeHash, so1.codeHash)
 	}
 	if !bytes.Equal(so0.code, so1.code) {
 		t.Fatalf("Code mismatch: have %v, want %v", so0.code, so1.code)
 	}
-
-	if len(so1.cachedStorage) != len(so0.cachedStorage) {
-		t.Errorf("Storage size mismatch: have %d, want %d", len(so1.cachedStorage), len(so0.cachedStorage))
+	if !bytes.Equal(so0.initCode, so1.initCode) {
+		t.Fatalf("InitCode mismatch: have %v, want %v", so0.initCode, so1.initCode)
 	}
-	for k, v := range so1.cachedStorage {
-		if so0.cachedStorage[k] != v {
-			t.Errorf("Storage key %x mismatch: have %v, want %v", k, so0.cachedStorage[k], v)
+
+	for k, v := range so1.storage {
+		if so0.storage[k] != v {
+			t.Fatalf("Storage key %s mismatch: have %v, want %v", k, so0.storage[k], v)
 		}
 	}
-	for k, v := range so0.cachedStorage {
-		if so1.cachedStorage[k] != v {
-			t.Errorf("Storage key %x mismatch: have %v, want none.", k, v)
+	for k, v := range so0.storage {
+		if so1.storage[k] != v {
+			t.Fatalf("Storage key %s mismatch: have %v, want none.", k, v)
 		}
 	}
 
-	if so0.suicided != so1.suicided {
-		t.Fatalf("suicided mismatch: have %v, want %v", so0.suicided, so1.suicided)
+	if so0.remove != so1.remove {
+		t.Fatalf("Remove mismatch: have %v, want %v", so0.remove, so1.remove)
 	}
 	if so0.deleted != so1.deleted {
 		t.Fatalf("Deleted mismatch: have %v, want %v", so0.deleted, so1.deleted)
 	}
+	if so0.dirty != so1.dirty {
+		t.Fatalf("Dirty mismatch: have %v, want %v", so0.dirty, so1.dirty)
+	}
 }

core/state/statedb.go

@@ -20,157 +20,74 @@ package state
 import (
 	"fmt"
 	"math/big"
-	"sort"
-	"sync"
 
 	"github.com/ethereum/go-ethereum/common"
 	"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/rlp"
 	"github.com/ethereum/go-ethereum/trie"
-	lru "github.com/hashicorp/golang-lru"
 )
 
 // The starting nonce determines the default nonce when new accounts are being
 // created.
 var StartingNonce uint64
 
-const (
-	// Number of past tries to keep. The arbitrarily chosen value here
-	// is max uncle depth + 1.
-	maxPastTries = 8
-
-	// Trie cache generation limit.
-	maxTrieCacheGen = 100
-
-	// Number of codehash->size associations to keep.
-	codeSizeCacheSize = 100000
-)
-
-type revision struct {
-	id           int
-	journalIndex int
-}
-
 // StateDBs within the ethereum protocol are used to store anything
 // within the merkle trie. StateDBs take care of caching and storing
 // nested states. It's the general query interface to retrieve:
 // * Contracts
 // * Accounts
 type StateDB struct {
-	db            ethdb.Database
-	trie          *trie.SecureTrie
-	pastTries     []*trie.SecureTrie
-	codeSizeCache *lru.Cache
+	db   ethdb.Database
+	trie *trie.SecureTrie
 
-	// This map holds 'live' objects, which will get modified while processing a state transition.
-	stateObjects      map[common.Address]*StateObject
-	stateObjectsDirty map[common.Address]struct{}
+	stateObjects map[string]*StateObject
 
-	// The refund counter, also used by state transitioning.
 	refund *big.Int
 
 	thash, bhash common.Hash
 	txIndex      int
 	logs         map[common.Hash]vm.Logs
 	logSize      uint
-
-	// Journal of state modifications. This is the backbone of
-	// Snapshot and RevertToSnapshot.
-	journal        journal
-	validRevisions []revision
-	nextRevisionId int
-
-	lock sync.Mutex
 }
 
 // Create a new state from a given trie
 func New(root common.Hash, db ethdb.Database) (*StateDB, error) {
-	tr, err := trie.NewSecure(root, db, maxTrieCacheGen)
-	if err != nil {
-		return nil, err
-	}
-	csc, _ := lru.New(codeSizeCacheSize)
-	return &StateDB{
-		db:                db,
-		trie:              tr,
-		codeSizeCache:     csc,
-		stateObjects:      make(map[common.Address]*StateObject),
-		stateObjectsDirty: make(map[common.Address]struct{}),
-		refund:            new(big.Int),
-		logs:              make(map[common.Hash]vm.Logs),
-	}, nil
-}
-
-// New creates a new statedb by reusing any journalled tries to avoid costly
-// disk io.
-func (self *StateDB) New(root common.Hash) (*StateDB, error) {
-	self.lock.Lock()
-	defer self.lock.Unlock()
-
-	tr, err := self.openTrie(root)
+	tr, err := trie.NewSecure(root, db)
 	if err != nil {
 		return nil, err
 	}
 	return &StateDB{
-		db:                self.db,
-		trie:              tr,
-		codeSizeCache:     self.codeSizeCache,
-		stateObjects:      make(map[common.Address]*StateObject),
-		stateObjectsDirty: make(map[common.Address]struct{}),
-		refund:            new(big.Int),
-		logs:              make(map[common.Hash]vm.Logs),
+		db:           db,
+		trie:         tr,
+		stateObjects: make(map[string]*StateObject),
+		refund:       new(big.Int),
+		logs:         make(map[common.Hash]vm.Logs),
 	}, nil
 }
 
 // Reset clears out all emphemeral state objects from the state db, but keeps
 // the underlying state trie to avoid reloading data for the next operations.
 func (self *StateDB) Reset(root common.Hash) error {
-	self.lock.Lock()
-	defer self.lock.Unlock()
-
-	tr, err := self.openTrie(root)
-	if err != nil {
-		return err
-	}
-	self.trie = tr
-	self.stateObjects = make(map[common.Address]*StateObject)
-	self.stateObjectsDirty = make(map[common.Address]struct{})
-	self.thash = common.Hash{}
-	self.bhash = common.Hash{}
-	self.txIndex = 0
-	self.logs = make(map[common.Hash]vm.Logs)
-	self.logSize = 0
-	self.clearJournalAndRefund()
-
-	return nil
-}
-
-// openTrie creates a trie. It uses an existing trie if one is available
-// from the journal if available.
-func (self *StateDB) openTrie(root common.Hash) (*trie.SecureTrie, error) {
-	for i := len(self.pastTries) - 1; i >= 0; i-- {
-		if self.pastTries[i].Hash() == root {
-			tr := *self.pastTries[i]
-			return &tr, nil
+	var (
+		err error
+		tr  = self.trie
+	)
+	if self.trie.Hash() != root {
+		if tr, err = trie.NewSecure(root, self.db); err != nil {
+			return err
 		}
 	}
-	return trie.NewSecure(root, self.db, maxTrieCacheGen)
-}
-
-func (self *StateDB) pushTrie(t *trie.SecureTrie) {
-	self.lock.Lock()
-	defer self.lock.Unlock()
-
-	if len(self.pastTries) >= maxPastTries {
-		copy(self.pastTries, self.pastTries[1:])
-		self.pastTries[len(self.pastTries)-1] = t
-	} else {
-		self.pastTries = append(self.pastTries, t)
+	*self = StateDB{
+		db:           self.db,
+		trie:         tr,
+		stateObjects: make(map[string]*StateObject),
+		refund:       new(big.Int),
+		logs:         make(map[common.Hash]vm.Logs),
 	}
+	return nil
 }
 
 func (self *StateDB) StartRecord(thash, bhash common.Hash, ti int) {
@@ -180,8 +97,6 @@ func (self *StateDB) StartRecord(thash, bhash common.Hash, ti int) {
 }
 
 func (self *StateDB) AddLog(log *vm.Log) {
-	self.journal = append(self.journal, addLogChange{txhash: self.thash})
-
 	log.TxHash = self.thash
 	log.BlockHash = self.bhash
 	log.TxIndex = uint(self.txIndex)
@@ -203,19 +118,15 @@ func (self *StateDB) Logs() vm.Logs {
 }
 
 func (self *StateDB) AddRefund(gas *big.Int) {
-	self.journal = append(self.journal, refundChange{prev: new(big.Int).Set(self.refund)})
 	self.refund.Add(self.refund, gas)
 }
 
-// Exist reports whether the given account address exists in the state.
-// Notably this also returns true for suicided accounts.
-func (self *StateDB) Exist(addr common.Address) bool {
+func (self *StateDB) HasAccount(addr common.Address) bool {
 	return self.GetStateObject(addr) != nil
 }
 
-func (self *StateDB) Empty(addr common.Address) bool {
-	so := self.GetStateObject(addr)
-	return so == nil || so.empty()
+func (self *StateDB) Exist(addr common.Address) bool {
+	return self.GetStateObject(addr) != nil
 }
 
 func (self *StateDB) GetAccount(addr common.Address) vm.Account {
@@ -226,15 +137,16 @@ func (self *StateDB) GetAccount(addr common.Address) vm.Account {
 func (self *StateDB) GetBalance(addr common.Address) *big.Int {
 	stateObject := self.GetStateObject(addr)
 	if stateObject != nil {
-		return stateObject.Balance()
+		return stateObject.balance
 	}
+
 	return common.Big0
 }
 
 func (self *StateDB) GetNonce(addr common.Address) uint64 {
 	stateObject := self.GetStateObject(addr)
 	if stateObject != nil {
-		return stateObject.Nonce()
+		return stateObject.nonce
 	}
 
 	return StartingNonce
@@ -243,50 +155,25 @@ func (self *StateDB) GetNonce(addr common.Address) uint64 {
 func (self *StateDB) GetCode(addr common.Address) []byte {
 	stateObject := self.GetStateObject(addr)
 	if stateObject != nil {
-		code := stateObject.Code(self.db)
-		key := common.BytesToHash(stateObject.CodeHash())
-		self.codeSizeCache.Add(key, len(code))
-		return code
+		return stateObject.code
 	}
+
 	return nil
 }
 
-func (self *StateDB) GetCodeSize(addr common.Address) int {
-	stateObject := self.GetStateObject(addr)
-	if stateObject == nil {
-		return 0
-	}
-	key := common.BytesToHash(stateObject.CodeHash())
-	if cached, ok := self.codeSizeCache.Get(key); ok {
-		return cached.(int)
-	}
-	size := len(stateObject.Code(self.db))
-	if stateObject.dbErr == nil {
-		self.codeSizeCache.Add(key, size)
-	}
-	return size
-}
-
-func (self *StateDB) GetCodeHash(addr common.Address) common.Hash {
-	stateObject := self.GetStateObject(addr)
-	if stateObject == nil {
-		return common.Hash{}
-	}
-	return common.BytesToHash(stateObject.CodeHash())
-}
-
 func (self *StateDB) GetState(a common.Address, b common.Hash) common.Hash {
 	stateObject := self.GetStateObject(a)
 	if stateObject != nil {
-		return stateObject.GetState(self.db, b)
+		return stateObject.GetState(b)
 	}
+
 	return common.Hash{}
 }
 
-func (self *StateDB) HasSuicided(addr common.Address) bool {
+func (self *StateDB) IsDeleted(addr common.Address) bool {
 	stateObject := self.GetStateObject(addr)
 	if stateObject != nil {
-		return stateObject.suicided
+		return stateObject.remove
 	}
 	return false
 }
@@ -302,13 +189,6 @@ func (self *StateDB) AddBalance(addr common.Address, amount *big.Int) {
 	}
 }
 
-func (self *StateDB) SetBalance(addr common.Address, amount *big.Int) {
-	stateObject := self.GetOrNewStateObject(addr)
-	if stateObject != nil {
-		stateObject.SetBalance(amount)
-	}
-}
-
 func (self *StateDB) SetNonce(addr common.Address, nonce uint64) {
 	stateObject := self.GetOrNewStateObject(addr)
 	if stateObject != nil {
@@ -319,43 +199,35 @@ func (self *StateDB) SetNonce(addr common.Address, nonce uint64) {
 func (self *StateDB) SetCode(addr common.Address, code []byte) {
 	stateObject := self.GetOrNewStateObject(addr)
 	if stateObject != nil {
-		stateObject.SetCode(crypto.Keccak256Hash(code), code)
+		stateObject.SetCode(code)
 	}
 }
 
 func (self *StateDB) SetState(addr common.Address, key common.Hash, value common.Hash) {
 	stateObject := self.GetOrNewStateObject(addr)
 	if stateObject != nil {
-		stateObject.SetState(self.db, key, value)
+		stateObject.SetState(key, value)
 	}
 }
 
-// Suicide marks the given account as suicided.
-// This clears the account balance.
-//
-// The account's state object is still available until the state is committed,
-// GetStateObject will return a non-nil account after Suicide.
-func (self *StateDB) Suicide(addr common.Address) bool {
+func (self *StateDB) Delete(addr common.Address) bool {
 	stateObject := self.GetStateObject(addr)
-	if stateObject == nil {
-		return false
+	if stateObject != nil {
+		stateObject.MarkForDeletion()
+		stateObject.balance = new(big.Int)
+
+		return true
 	}
-	self.journal = append(self.journal, suicideChange{
-		account:     &addr,
-		prev:        stateObject.suicided,
-		prevbalance: new(big.Int).Set(stateObject.Balance()),
-	})
-	stateObject.markSuicided()
-	stateObject.data.Balance = new(big.Int)
-	return true
+
+	return false
 }
 
 //
 // Setting, updating & deleting state object methods
 //
 
-// updateStateObject writes the given object to the trie.
-func (self *StateDB) updateStateObject(stateObject *StateObject) {
+// Update the given state object and apply it to state trie
+func (self *StateDB) UpdateStateObject(stateObject *StateObject) {
 	addr := stateObject.Address()
 	data, err := rlp.EncodeToBytes(stateObject)
 	if err != nil {
@@ -364,156 +236,117 @@ func (self *StateDB) updateStateObject(stateObject *StateObject) {
 	self.trie.Update(addr[:], data)
 }
 
-// deleteStateObject removes the given object from the state trie.
-func (self *StateDB) deleteStateObject(stateObject *StateObject) {
+// Delete the given state object and delete it from the state trie
+func (self *StateDB) DeleteStateObject(stateObject *StateObject) {
 	stateObject.deleted = true
+
 	addr := stateObject.Address()
 	self.trie.Delete(addr[:])
+	//delete(self.stateObjects, addr.Str())
 }
 
-// Retrieve a state object given my the address. Returns nil if not found.
+// Retrieve a state object given my the address. Nil if not found
 func (self *StateDB) GetStateObject(addr common.Address) (stateObject *StateObject) {
-	// Prefer 'live' objects.
-	if obj := self.stateObjects[addr]; obj != nil {
-		if obj.deleted {
-			return nil
+	stateObject = self.stateObjects[addr.Str()]
+	if stateObject != nil {
+		if stateObject.deleted {
+			stateObject = nil
 		}
-		return obj
+
+		return stateObject
 	}
 
-	// Load the object from the database.
-	enc := self.trie.Get(addr[:])
-	if len(enc) == 0 {
+	data := self.trie.Get(addr[:])
+	if len(data) == 0 {
 		return nil
 	}
-	var data Account
-	if err := rlp.DecodeBytes(enc, &data); err != nil {
+	stateObject, err := DecodeObject(addr, self.db, data)
+	if err != nil {
 		glog.Errorf("can't decode object at %x: %v", addr[:], err)
 		return nil
 	}
-	// Insert into the live set.
-	obj := newObject(self, addr, data, self.MarkStateObjectDirty)
-	self.setStateObject(obj)
-	return obj
+	self.SetStateObject(stateObject)
+	return stateObject
 }
 
-func (self *StateDB) setStateObject(object *StateObject) {
-	self.stateObjects[object.Address()] = object
+func (self *StateDB) SetStateObject(object *StateObject) {
+	self.stateObjects[object.Address().Str()] = object
 }
 
 // Retrieve a state object or create a new state object if nil
 func (self *StateDB) GetOrNewStateObject(addr common.Address) *StateObject {
 	stateObject := self.GetStateObject(addr)
 	if stateObject == nil || stateObject.deleted {
-		stateObject, _ = self.createObject(addr)
+		stateObject = self.CreateStateObject(addr)
 	}
+
 	return stateObject
 }
 
-// MarkStateObjectDirty adds the specified object to the dirty map to avoid costly
-// state object cache iteration to find a handful of modified ones.
-func (self *StateDB) MarkStateObjectDirty(addr common.Address) {
-	self.stateObjectsDirty[addr] = struct{}{}
-}
-
-// createObject creates a new state object. If there is an existing account with
-// the given address, it is overwritten and returned as the second return value.
-func (self *StateDB) createObject(addr common.Address) (newobj, prev *StateObject) {
-	prev = self.GetStateObject(addr)
-	newobj = newObject(self, addr, Account{}, self.MarkStateObjectDirty)
-	newobj.setNonce(StartingNonce) // sets the object to dirty
-	if prev == nil {
-		if glog.V(logger.Core) {
-			glog.Infof("(+) %x\n", addr)
-		}
-		self.journal = append(self.journal, createObjectChange{account: &addr})
-	} else {
-		self.journal = append(self.journal, resetObjectChange{prev: prev})
+// NewStateObject create a state object whether it exist in the trie or not
+func (self *StateDB) newStateObject(addr common.Address) *StateObject {
+	if glog.V(logger.Core) {
+		glog.Infof("(+) %x\n", addr)
 	}
-	self.setStateObject(newobj)
-	return newobj, prev
+
+	stateObject := NewStateObject(addr, self.db)
+	stateObject.SetNonce(StartingNonce)
+	self.stateObjects[addr.Str()] = stateObject
+
+	return stateObject
+}
+
+// Creates creates a new state object and takes ownership. This is different from "NewStateObject"
+func (self *StateDB) CreateStateObject(addr common.Address) *StateObject {
+	// Get previous (if any)
+	so := self.GetStateObject(addr)
+	// Create a new one
+	newSo := self.newStateObject(addr)
+
+	// If it existed set the balance to the new account
+	if so != nil {
+		newSo.balance = so.balance
+	}
+
+	return newSo
 }
 
-// CreateAccount explicitly creates a state object. If a state object with the address
-// already exists the balance is carried over to the new account.
-//
-// CreateAccount is called during the EVM CREATE operation. The situation might arise that
-// a contract does the following:
-//
-//   1. sends funds to sha(account ++ (nonce + 1))
-//   2. tx_create(sha(account ++ nonce)) (note that this gets the address of 1)
-//
-// Carrying over the balance ensures that Ether doesn't disappear.
 func (self *StateDB) CreateAccount(addr common.Address) vm.Account {
-	new, prev := self.createObject(addr)
-	if prev != nil {
-		new.setBalance(prev.data.Balance)
-	}
-	return new
+	return self.CreateStateObject(addr)
 }
 
-// Copy creates a deep, independent copy of the state.
-// Snapshots of the copied state cannot be applied to the copy.
-func (self *StateDB) Copy() *StateDB {
-	self.lock.Lock()
-	defer self.lock.Unlock()
+//
+// Setting, copying of the state methods
+//
 
-	// Copy all the basic fields, initialize the memory ones
-	state := &StateDB{
-		db:                self.db,
-		trie:              self.trie,
-		pastTries:         self.pastTries,
-		codeSizeCache:     self.codeSizeCache,
-		stateObjects:      make(map[common.Address]*StateObject, len(self.stateObjectsDirty)),
-		stateObjectsDirty: make(map[common.Address]struct{}, len(self.stateObjectsDirty)),
-		refund:            new(big.Int).Set(self.refund),
-		logs:              make(map[common.Hash]vm.Logs, len(self.logs)),
-		logSize:           self.logSize,
-	}
-	// Copy the dirty states and logs
-	for addr, _ := range self.stateObjectsDirty {
-		state.stateObjects[addr] = self.stateObjects[addr].deepCopy(state, state.MarkStateObjectDirty)
-		state.stateObjectsDirty[addr] = struct{}{}
+func (self *StateDB) Copy() *StateDB {
+	// ignore error - we assume state-to-be-copied always exists
+	state, _ := New(common.Hash{}, self.db)
+	state.trie = self.trie
+	for k, stateObject := range self.stateObjects {
+		state.stateObjects[k] = stateObject.Copy()
 	}
+
+	state.refund.Set(self.refund)
+
 	for hash, logs := range self.logs {
 		state.logs[hash] = make(vm.Logs, len(logs))
 		copy(state.logs[hash], logs)
 	}
+	state.logSize = self.logSize
+
 	return state
 }
 
-// Snapshot returns an identifier for the current revision of the state.
-func (self *StateDB) Snapshot() int {
-	id := self.nextRevisionId
-	self.nextRevisionId++
-	self.validRevisions = append(self.validRevisions, revision{id, len(self.journal)})
-	return id
+func (self *StateDB) Set(state *StateDB) {
+	self.trie = state.trie
+	self.stateObjects = state.stateObjects
+
+	self.refund = state.refund
+	self.logs = state.logs
+	self.logSize = state.logSize
 }
 
-// RevertToSnapshot reverts all state changes made since the given revision.
-func (self *StateDB) RevertToSnapshot(revid int) {
-	// Find the snapshot in the stack of valid snapshots.
-	idx := sort.Search(len(self.validRevisions), func(i int) bool {
-		return self.validRevisions[i].id >= revid
-	})
-	if idx == len(self.validRevisions) || self.validRevisions[idx].id != revid {
-		panic(fmt.Errorf("revision id %v cannot be reverted", revid))
-	}
-	snapshot := self.validRevisions[idx].journalIndex
-
-	// Replay the journal to undo changes.
-	for i := len(self.journal) - 1; i >= snapshot; i-- {
-		self.journal[i].undo(self)
-	}
-	self.journal = self.journal[:snapshot]
-
-	// Remove invalidated snapshots from the stack.
-	self.validRevisions = self.validRevisions[:idx]
-}
-
-// GetRefund returns the current value of the refund counter.
-// The return value must not be modified by the caller and will become
-// invalid at the next call to AddRefund.
 func (self *StateDB) GetRefund() *big.Int {
 	return self.refund
 }
@@ -521,18 +354,19 @@ func (self *StateDB) GetRefund() *big.Int {
 // IntermediateRoot computes the current root hash of the state trie.
 // It is called in between transactions to get the root hash that
 // goes into transaction receipts.
-func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
-	for addr, _ := range s.stateObjectsDirty {
-		stateObject := s.stateObjects[addr]
-		if stateObject.suicided || (deleteEmptyObjects && stateObject.empty()) {
-			s.deleteStateObject(stateObject)
-		} else {
-			stateObject.updateRoot(s.db)
-			s.updateStateObject(stateObject)
+func (s *StateDB) IntermediateRoot() common.Hash {
+	s.refund = new(big.Int)
+	for _, stateObject := range s.stateObjects {
+		if stateObject.dirty {
+			if stateObject.remove {
+				s.DeleteStateObject(stateObject)
+			} else {
+				stateObject.Update()
+				s.UpdateStateObject(stateObject)
+			}
+			stateObject.dirty = false
 		}
 	}
-	// Invalidate journal because reverting across transactions is not allowed.
-	s.clearJournalAndRefund()
 	return s.trie.Hash()
 }
 
@@ -542,75 +376,76 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
 // DeleteSuicides should not be used for consensus related updates
 // under any circumstances.
 func (s *StateDB) DeleteSuicides() {
-	// Reset refund so that any used-gas calculations can use this method.
-	s.clearJournalAndRefund()
-
-	for addr, _ := range s.stateObjectsDirty {
-		stateObject := s.stateObjects[addr]
-
-		// If the object has been removed by a suicide
-		// flag the object as deleted.
-		if stateObject.suicided {
-			stateObject.deleted = true
+	// Reset refund so that any used-gas calculations can use
+	// this method.
+	s.refund = new(big.Int)
+	for _, stateObject := range s.stateObjects {
+		if stateObject.dirty {
+			// If the object has been removed by a suicide
+			// flag the object as deleted.
+			if stateObject.remove {
+				stateObject.deleted = true
+			}
+			stateObject.dirty = false
 		}
-		delete(s.stateObjectsDirty, addr)
 	}
 }
 
 // Commit commits all state changes to the database.
-func (s *StateDB) Commit(deleteEmptyObjects bool) (root common.Hash, err error) {
-	root, batch := s.CommitBatch(deleteEmptyObjects)
+func (s *StateDB) Commit() (root common.Hash, err error) {
+	root, batch := s.CommitBatch()
 	return root, batch.Write()
 }
 
 // CommitBatch commits all state changes to a write batch but does not
 // execute the batch. It is used to validate state changes against
 // the root hash stored in a block.
-func (s *StateDB) CommitBatch(deleteEmptyObjects bool) (root common.Hash, batch ethdb.Batch) {
+func (s *StateDB) CommitBatch() (root common.Hash, batch ethdb.Batch) {
 	batch = s.db.NewBatch()
-	root, _ = s.commit(batch, deleteEmptyObjects)
-
+	root, _ = s.commit(batch)
 	return root, batch
 }
 
-func (s *StateDB) clearJournalAndRefund() {
-	s.journal = nil
-	s.validRevisions = s.validRevisions[:0]
+func (s *StateDB) commit(db trie.DatabaseWriter) (common.Hash, error) {
 	s.refund = new(big.Int)
-}
 
-func (s *StateDB) commit(dbw trie.DatabaseWriter, deleteEmptyObjects bool) (root common.Hash, err error) {
-	defer s.clearJournalAndRefund()
-
-	// Commit objects to the trie.
-	for addr, stateObject := range s.stateObjects {
-		_, isDirty := s.stateObjectsDirty[addr]
-		switch {
-		case stateObject.suicided || (isDirty && deleteEmptyObjects && stateObject.empty()):
+	for _, stateObject := range s.stateObjects {
+		if stateObject.remove {
 			// If the object has been removed, don't bother syncing it
 			// and just mark it for deletion in the trie.
-			s.deleteStateObject(stateObject)
-		case isDirty:
+			s.DeleteStateObject(stateObject)
+		} else {
 			// Write any contract code associated with the state object
-			if stateObject.code != nil && stateObject.dirtyCode {
-				if err := dbw.Put(stateObject.CodeHash(), stateObject.code); err != nil {
+			if len(stateObject.code) > 0 {
+				if err := db.Put(stateObject.codeHash, stateObject.code); err != nil {
 					return common.Hash{}, err
 				}
-				stateObject.dirtyCode = false
 			}
-			// Write any storage changes in the state object to its storage trie.
-			if err := stateObject.CommitTrie(s.db, dbw); err != nil {
+			// Write any storage changes in the state object to its trie.
+			stateObject.Update()
+
+			// Commit the trie of the object to the batch.
+			// This updates the trie root internally, so
+			// getting the root hash of the storage trie
+			// through UpdateStateObject is fast.
+			if _, err := stateObject.trie.CommitTo(db); err != nil {
 				return common.Hash{}, err
 			}
-			// Update the object in the main account trie.
-			s.updateStateObject(stateObject)
+			// Update the object in the account trie.
+			s.UpdateStateObject(stateObject)
 		}
-		delete(s.stateObjectsDirty, addr)
+		stateObject.dirty = false
+	}
+	return s.trie.CommitTo(db)
+}
+
+func (self *StateDB) Refunds() *big.Int {
+	return self.refund
+}
+
+// Debug stuff
+func (self *StateDB) CreateOutputForDiff() {
+	for _, stateObject := range self.stateObjects {
+		stateObject.CreateOutputForDiff()
 	}
-	// Write trie changes.
-	root, err = s.trie.CommitTo(dbw)
-	if err == nil {
-		s.pushTrie(s.trie)
-	}
-	return root, err
 }

core/state/statedb_test.go

@@ -17,19 +17,10 @@
 package state
 
 import (
-	"bytes"
-	"encoding/binary"
-	"fmt"
-	"math"
 	"math/big"
-	"math/rand"
-	"reflect"
-	"strings"
 	"testing"
-	"testing/quick"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/ethdb"
 )
 
@@ -42,16 +33,16 @@ func TestUpdateLeaks(t *testing.T) {
 
 	// Update it with some accounts
 	for i := byte(0); i < 255; i++ {
-		addr := common.BytesToAddress([]byte{i})
-		state.AddBalance(addr, big.NewInt(int64(11*i)))
-		state.SetNonce(addr, uint64(42*i))
+		obj := state.GetOrNewStateObject(common.BytesToAddress([]byte{i}))
+		obj.AddBalance(big.NewInt(int64(11 * i)))
+		obj.SetNonce(uint64(42 * i))
 		if i%2 == 0 {
-			state.SetState(addr, common.BytesToHash([]byte{i, i, i}), common.BytesToHash([]byte{i, i, i, i}))
+			obj.SetState(common.BytesToHash([]byte{i, i, i}), common.BytesToHash([]byte{i, i, i, i}))
 		}
 		if i%3 == 0 {
-			state.SetCode(addr, []byte{i, i, i, i, i})
+			obj.SetCode([]byte{i, i, i, i, i})
 		}
-		state.IntermediateRoot(false)
+		state.UpdateStateObject(obj)
 	}
 	// Ensure that no data was leaked into the database
 	for _, key := range db.Keys() {
@@ -69,38 +60,51 @@ func TestIntermediateLeaks(t *testing.T) {
 	transState, _ := New(common.Hash{}, transDb)
 	finalState, _ := New(common.Hash{}, finalDb)
 
-	modify := func(state *StateDB, addr common.Address, i, tweak byte) {
-		state.SetBalance(addr, big.NewInt(int64(11*i)+int64(tweak)))
-		state.SetNonce(addr, uint64(42*i+tweak))
+	// Update the states with some objects
+	for i := byte(0); i < 255; i++ {
+		// Create a new state object with some data into the transition database
+		obj := transState.GetOrNewStateObject(common.BytesToAddress([]byte{i}))
+		obj.SetBalance(big.NewInt(int64(11 * i)))
+		obj.SetNonce(uint64(42 * i))
 		if i%2 == 0 {
-			state.SetState(addr, common.Hash{i, i, i, 0}, common.Hash{})
-			state.SetState(addr, common.Hash{i, i, i, tweak}, common.Hash{i, i, i, i, tweak})
+			obj.SetState(common.BytesToHash([]byte{i, i, i, 0}), common.BytesToHash([]byte{i, i, i, i, 0}))
 		}
 		if i%3 == 0 {
-			state.SetCode(addr, []byte{i, i, i, i, i, tweak})
+			obj.SetCode([]byte{i, i, i, i, i, 0})
 		}
-	}
+		transState.UpdateStateObject(obj)
 
-	// Modify the transient state.
-	for i := byte(0); i < 255; i++ {
-		modify(transState, common.Address{byte(i)}, i, 0)
-	}
-	// Write modifications to trie.
-	transState.IntermediateRoot(false)
+		// Overwrite all the data with new values in the transition database
+		obj.SetBalance(big.NewInt(int64(11*i + 1)))
+		obj.SetNonce(uint64(42*i + 1))
+		if i%2 == 0 {
+			obj.SetState(common.BytesToHash([]byte{i, i, i, 0}), common.Hash{})
+			obj.SetState(common.BytesToHash([]byte{i, i, i, 1}), common.BytesToHash([]byte{i, i, i, i, 1}))
+		}
+		if i%3 == 0 {
+			obj.SetCode([]byte{i, i, i, i, i, 1})
+		}
+		transState.UpdateStateObject(obj)
 
-	// Overwrite all the data with new values in the transient database.
-	for i := byte(0); i < 255; i++ {
-		modify(transState, common.Address{byte(i)}, i, 99)
-		modify(finalState, common.Address{byte(i)}, i, 99)
+		// Create the final state object directly in the final database
+		obj = finalState.GetOrNewStateObject(common.BytesToAddress([]byte{i}))
+		obj.SetBalance(big.NewInt(int64(11*i + 1)))
+		obj.SetNonce(uint64(42*i + 1))
+		if i%2 == 0 {
+			obj.SetState(common.BytesToHash([]byte{i, i, i, 1}), common.BytesToHash([]byte{i, i, i, i, 1}))
+		}
+		if i%3 == 0 {
+			obj.SetCode([]byte{i, i, i, i, i, 1})
+		}
+		finalState.UpdateStateObject(obj)
 	}
-
-	// Commit and cross check the databases.
-	if _, err := transState.Commit(false); err != nil {
+	if _, err := transState.Commit(); err != nil {
 		t.Fatalf("failed to commit transition state: %v", err)
 	}
-	if _, err := finalState.Commit(false); err != nil {
+	if _, err := finalState.Commit(); err != nil {
 		t.Fatalf("failed to commit final state: %v", err)
 	}
+	// Cross check the databases to ensure they are the same
 	for _, key := range finalDb.Keys() {
 		if _, err := transDb.Get(key); err != nil {
 			val, _ := finalDb.Get(key)
@@ -114,243 +118,3 @@ func TestIntermediateLeaks(t *testing.T) {
 		}
 	}
 }
-
-func TestSnapshotRandom(t *testing.T) {
-	config := &quick.Config{MaxCount: 1000}
-	err := quick.Check((*snapshotTest).run, config)
-	if cerr, ok := err.(*quick.CheckError); ok {
-		test := cerr.In[0].(*snapshotTest)
-		t.Errorf("%v:\n%s", test.err, test)
-	} else if err != nil {
-		t.Error(err)
-	}
-}
-
-// A snapshotTest checks that reverting StateDB snapshots properly undoes all changes
-// captured by the snapshot. Instances of this test with pseudorandom content are created
-// by Generate.
-//
-// The test works as follows:
-//
-// A new state is created and all actions are applied to it. Several snapshots are taken
-// in between actions. The test then reverts each snapshot. For each snapshot the actions
-// leading up to it are replayed on a fresh, empty state. The behaviour of all public
-// accessor methods on the reverted state must match the return value of the equivalent
-// methods on the replayed state.
-type snapshotTest struct {
-	addrs     []common.Address // all account addresses
-	actions   []testAction     // modifications to the state
-	snapshots []int            // actions indexes at which snapshot is taken
-	err       error            // failure details are reported through this field
-}
-
-type testAction struct {
-	name   string
-	fn     func(testAction, *StateDB)
-	args   []int64
-	noAddr bool
-}
-
-// newTestAction creates a random action that changes state.
-func newTestAction(addr common.Address, r *rand.Rand) testAction {
-	actions := []testAction{
-		{
-			name: "SetBalance",
-			fn: func(a testAction, s *StateDB) {
-				s.SetBalance(addr, big.NewInt(a.args[0]))
-			},
-			args: make([]int64, 1),
-		},
-		{
-			name: "AddBalance",
-			fn: func(a testAction, s *StateDB) {
-				s.AddBalance(addr, big.NewInt(a.args[0]))
-			},
-			args: make([]int64, 1),
-		},
-		{
-			name: "SetNonce",
-			fn: func(a testAction, s *StateDB) {
-				s.SetNonce(addr, uint64(a.args[0]))
-			},
-			args: make([]int64, 1),
-		},
-		{
-			name: "SetState",
-			fn: func(a testAction, s *StateDB) {
-				var key, val common.Hash
-				binary.BigEndian.PutUint16(key[:], uint16(a.args[0]))
-				binary.BigEndian.PutUint16(val[:], uint16(a.args[1]))
-				s.SetState(addr, key, val)
-			},
-			args: make([]int64, 2),
-		},
-		{
-			name: "SetCode",
-			fn: func(a testAction, s *StateDB) {
-				code := make([]byte, 16)
-				binary.BigEndian.PutUint64(code, uint64(a.args[0]))
-				binary.BigEndian.PutUint64(code[8:], uint64(a.args[1]))
-				s.SetCode(addr, code)
-			},
-			args: make([]int64, 2),
-		},
-		{
-			name: "CreateAccount",
-			fn: func(a testAction, s *StateDB) {
-				s.CreateAccount(addr)
-			},
-		},
-		{
-			name: "Suicide",
-			fn: func(a testAction, s *StateDB) {
-				s.Suicide(addr)
-			},
-		},
-		{
-			name: "AddRefund",
-			fn: func(a testAction, s *StateDB) {
-				s.AddRefund(big.NewInt(a.args[0]))
-			},
-			args:   make([]int64, 1),
-			noAddr: true,
-		},
-		{
-			name: "AddLog",
-			fn: func(a testAction, s *StateDB) {
-				data := make([]byte, 2)
-				binary.BigEndian.PutUint16(data, uint16(a.args[0]))
-				s.AddLog(&vm.Log{Address: addr, Data: data})
-			},
-			args: make([]int64, 1),
-		},
-	}
-	action := actions[r.Intn(len(actions))]
-	var nameargs []string
-	if !action.noAddr {
-		nameargs = append(nameargs, addr.Hex())
-	}
-	for _, i := range action.args {
-		action.args[i] = rand.Int63n(100)
-		nameargs = append(nameargs, fmt.Sprint(action.args[i]))
-	}
-	action.name += strings.Join(nameargs, ", ")
-	return action
-}
-
-// Generate returns a new snapshot test of the given size. All randomness is
-// derived from r.
-func (*snapshotTest) Generate(r *rand.Rand, size int) reflect.Value {
-	// Generate random actions.
-	addrs := make([]common.Address, 50)
-	for i := range addrs {
-		addrs[i][0] = byte(i)
-	}
-	actions := make([]testAction, size)
-	for i := range actions {
-		addr := addrs[r.Intn(len(addrs))]
-		actions[i] = newTestAction(addr, r)
-	}
-	// Generate snapshot indexes.
-	nsnapshots := int(math.Sqrt(float64(size)))
-	if size > 0 && nsnapshots == 0 {
-		nsnapshots = 1
-	}
-	snapshots := make([]int, nsnapshots)
-	snaplen := len(actions) / nsnapshots
-	for i := range snapshots {
-		// Try to place the snapshots some number of actions apart from each other.
-		snapshots[i] = (i * snaplen) + r.Intn(snaplen)
-	}
-	return reflect.ValueOf(&snapshotTest{addrs, actions, snapshots, nil})
-}
-
-func (test *snapshotTest) String() string {
-	out := new(bytes.Buffer)
-	sindex := 0
-	for i, action := range test.actions {
-		if len(test.snapshots) > sindex && i == test.snapshots[sindex] {
-			fmt.Fprintf(out, "---- snapshot %d ----\n", sindex)
-			sindex++
-		}
-		fmt.Fprintf(out, "%4d: %s\n", i, action.name)
-	}
-	return out.String()
-}
-
-func (test *snapshotTest) run() bool {
-	// Run all actions and create snapshots.
-	var (
-		db, _        = ethdb.NewMemDatabase()
-		state, _     = New(common.Hash{}, db)
-		snapshotRevs = make([]int, len(test.snapshots))
-		sindex       = 0
-	)
-	for i, action := range test.actions {
-		if len(test.snapshots) > sindex && i == test.snapshots[sindex] {
-			snapshotRevs[sindex] = state.Snapshot()
-			sindex++
-		}
-		action.fn(action, state)
-	}
-
-	// Revert all snapshots in reverse order. Each revert must yield a state
-	// that is equivalent to fresh state with all actions up the snapshot applied.
-	for sindex--; sindex >= 0; sindex-- {
-		checkstate, _ := New(common.Hash{}, db)
-		for _, action := range test.actions[:test.snapshots[sindex]] {
-			action.fn(action, checkstate)
-		}
-		state.RevertToSnapshot(snapshotRevs[sindex])
-		if err := test.checkEqual(state, checkstate); err != nil {
-			test.err = fmt.Errorf("state mismatch after revert to snapshot %d\n%v", sindex, err)
-			return false
-		}
-	}
-	return true
-}
-
-// checkEqual checks that methods of state and checkstate return the same values.
-func (test *snapshotTest) checkEqual(state, checkstate *StateDB) error {
-	for _, addr := range test.addrs {
-		var err error
-		checkeq := func(op string, a, b interface{}) bool {
-			if err == nil && !reflect.DeepEqual(a, b) {
-				err = fmt.Errorf("got %s(%s) == %v, want %v", op, addr.Hex(), a, b)
-				return false
-			}
-			return true
-		}
-		// Check basic accessor methods.
-		checkeq("Exist", state.Exist(addr), checkstate.Exist(addr))
-		checkeq("HasSuicided", state.HasSuicided(addr), checkstate.HasSuicided(addr))
-		checkeq("GetBalance", state.GetBalance(addr), checkstate.GetBalance(addr))
-		checkeq("GetNonce", state.GetNonce(addr), checkstate.GetNonce(addr))
-		checkeq("GetCode", state.GetCode(addr), checkstate.GetCode(addr))
-		checkeq("GetCodeHash", state.GetCodeHash(addr), checkstate.GetCodeHash(addr))
-		checkeq("GetCodeSize", state.GetCodeSize(addr), checkstate.GetCodeSize(addr))
-		// Check storage.
-		if obj := state.GetStateObject(addr); obj != nil {
-			obj.ForEachStorage(func(key, val common.Hash) bool {
-				return checkeq("GetState("+key.Hex()+")", val, checkstate.GetState(addr, key))
-			})
-			checkobj := checkstate.GetStateObject(addr)
-			checkobj.ForEachStorage(func(key, checkval common.Hash) bool {
-				return checkeq("GetState("+key.Hex()+")", state.GetState(addr, key), checkval)
-			})
-		}
-		if err != nil {
-			return err
-		}
-	}
-
-	if state.GetRefund().Cmp(checkstate.GetRefund()) != 0 {
-		return fmt.Errorf("got GetRefund() == %d, want GetRefund() == %d",
-			state.GetRefund(), checkstate.GetRefund())
-	}
-	if !reflect.DeepEqual(state.GetLogs(common.Hash{}), checkstate.GetLogs(common.Hash{})) {
-		return fmt.Errorf("got GetLogs(common.Hash{}) == %v, want GetLogs(common.Hash{}) == %v",
-			state.GetLogs(common.Hash{}), checkstate.GetLogs(common.Hash{}))
-	}
-	return nil
-}

core/state/sync_test.go

@@ -54,13 +54,16 @@ func makeTestState() (ethdb.Database, common.Hash, []*testAccount) {
 		acc.nonce = uint64(42 * i)
 
 		if i%3 == 0 {
-			obj.SetCode(crypto.Keccak256Hash([]byte{i, i, i, i, i}), []byte{i, i, i, i, i})
+			obj.SetCode([]byte{i, i, i, i, i})
 			acc.code = []byte{i, i, i, i, i}
 		}
-		state.updateStateObject(obj)
+		state.UpdateStateObject(obj)
 		accounts = append(accounts, acc)
 	}
-	root, _ := state.Commit(false)
+	root, _ := state.Commit()
+
+	// Remove any potentially cached data from the test state creation
+	trie.ClearGlobalCache()
 
 	// Return the generated state
 	return db, root, accounts
@@ -69,6 +72,9 @@ func makeTestState() (ethdb.Database, common.Hash, []*testAccount) {
 // checkStateAccounts cross references a reconstructed state with an expected
 // account array.
 func checkStateAccounts(t *testing.T, db ethdb.Database, root common.Hash, accounts []*testAccount) {
+	// Remove any potentially cached data from the state synchronisation
+	trie.ClearGlobalCache()
+
 	// Check root availability and state contents
 	state, err := New(root, db)
 	if err != nil {
@@ -92,6 +98,9 @@ func checkStateAccounts(t *testing.T, db ethdb.Database, root common.Hash, accou
 
 // checkStateConsistency checks that all nodes in a state trie are indeed present.
 func checkStateConsistency(db ethdb.Database, root common.Hash) error {
+	// Remove any potentially cached data from the test state creation or previous checks
+	trie.ClearGlobalCache()
+
 	// Create and iterate a state trie rooted in a sub-node
 	if _, err := db.Get(root.Bytes()); err != nil {
 		return nil // Consider a non existent state consistent

core/state_processor.go

@@ -25,7 +25,6 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/logger/glog"
-	"github.com/ethereum/go-ethereum/params"
 )
 
 var (
@@ -38,12 +37,12 @@ var (
 //
 // StateProcessor implements Processor.
 type StateProcessor struct {
-	config *params.ChainConfig
+	config *ChainConfig
 	bc     *BlockChain
 }
 
 // NewStateProcessor initialises a new StateProcessor.
-func NewStateProcessor(config *params.ChainConfig, bc *BlockChain) *StateProcessor {
+func NewStateProcessor(config *ChainConfig, bc *BlockChain) *StateProcessor {
 	return &StateProcessor{
 		config: config,
 		bc:     bc,
@@ -66,11 +65,7 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 		allLogs      vm.Logs
 		gp           = new(GasPool).AddGas(block.GasLimit())
 	)
-	// Mutate the the block and state according to any hard-fork specs
-	if p.config.DAOForkSupport && p.config.DAOForkBlock != nil && p.config.DAOForkBlock.Cmp(block.Number()) == 0 {
-		ApplyDAOHardFork(statedb)
-	}
-	// Iterate over and process the individual transactions
+
 	for i, tx := range block.Transactions() {
 		statedb.StartRecord(tx.Hash(), block.Hash(), i)
 		receipt, logs, _, err := ApplyTransaction(p.config, p.bc, gp, statedb, header, tx, totalUsedGas, cfg)
@@ -90,18 +85,7 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 //
 // ApplyTransactions returns the generated receipts and vm logs during the
 // execution of the state transition phase.
-func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *big.Int, cfg vm.Config) (*types.Receipt, vm.Logs, *big.Int, error) {
-	var signer types.Signer
-	switch {
-	case config.IsEIP155(header.Number):
-		signer = types.NewEIP155Signer(config.ChainId)
-	case config.IsHomestead(header.Number):
-		signer = types.HomesteadSigner{}
-	default:
-		signer = types.FrontierSigner{}
-	}
-	tx.SetSigner(signer)
-
+func ApplyTransaction(config *ChainConfig, bc *BlockChain, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *big.Int, cfg vm.Config) (*types.Receipt, vm.Logs, *big.Int, error) {
 	_, gas, err := ApplyMessage(NewEnv(statedb, config, bc, tx, header, cfg), tx, gp)
 	if err != nil {
 		return nil, nil, nil, err
@@ -109,7 +93,7 @@ func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, gp *GasPool, s
 
 	// Update the state with pending changes
 	usedGas.Add(usedGas, gas)
-	receipt := types.NewReceipt(statedb.IntermediateRoot(config.IsEIP158(header.Number)).Bytes(), usedGas)
+	receipt := types.NewReceipt(statedb.IntermediateRoot().Bytes(), usedGas)
 	receipt.TxHash = tx.Hash()
 	receipt.GasUsed = new(big.Int).Set(gas)
 	if MessageCreatesContract(tx) {

core/state_transition.go

@@ -138,7 +138,7 @@ func (self *StateTransition) from() (vm.Account, error) {
 		f   common.Address
 		err error
 	)
-	if self.env.ChainConfig().IsHomestead(self.env.BlockNumber()) {
+	if self.env.RuleSet().IsHomestead(self.env.BlockNumber()) {
 		f, err = self.msg.From()
 	} else {
 		f, err = self.msg.FromFrontier()
@@ -231,7 +231,7 @@ func (self *StateTransition) TransitionDb() (ret []byte, requiredGas, usedGas *b
 	msg := self.msg
 	sender, _ := self.from() // err checked in preCheck
 
-	homestead := self.env.ChainConfig().IsHomestead(self.env.BlockNumber())
+	homestead := self.env.RuleSet().IsHomestead(self.env.BlockNumber())
 	contractCreation := MessageCreatesContract(msg)
 	// Pay intrinsic gas
 	if err = self.useGas(IntrinsicGas(self.data, contractCreation, homestead)); err != nil {

core/tx_list.go

@@ -1,342 +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 core
-
-import (
-	"container/heap"
-	"math"
-	"math/big"
-	"sort"
-
-	"github.com/ethereum/go-ethereum/core/types"
-)
-
-// nonceHeap is a heap.Interface implementation over 64bit unsigned integers for
-// retrieving sorted transactions from the possibly gapped future queue.
-type nonceHeap []uint64
-
-func (h nonceHeap) Len() int           { return len(h) }
-func (h nonceHeap) Less(i, j int) bool { return h[i] < h[j] }
-func (h nonceHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
-
-func (h *nonceHeap) Push(x interface{}) {
-	*h = append(*h, x.(uint64))
-}
-
-func (h *nonceHeap) Pop() interface{} {
-	old := *h
-	n := len(old)
-	x := old[n-1]
-	*h = old[0 : n-1]
-	return x
-}
-
-// txSortedMap is a nonce->transaction hash map with a heap based index to allow
-// iterating over the contents in a nonce-incrementing way.
-type txSortedMap struct {
-	items map[uint64]*types.Transaction // Hash map storing the transaction data
-	index *nonceHeap                    // Heap of nonces of all the stored transactions (non-strict mode)
-	cache types.Transactions            // Cache of the transactions already sorted
-}
-
-// newTxSortedMap creates a new sorted transaction map.
-func newTxSortedMap() *txSortedMap {
-	return &txSortedMap{
-		items: make(map[uint64]*types.Transaction),
-		index: &nonceHeap{},
-	}
-}
-
-// Get retrieves the current transactions associated with the given nonce.
-func (m *txSortedMap) Get(nonce uint64) *types.Transaction {
-	return m.items[nonce]
-}
-
-// Put inserts a new transaction into the map, also updating the map's nonce
-// index. If a transaction already exists with the same nonce, it's overwritten.
-func (m *txSortedMap) Put(tx *types.Transaction) {
-	nonce := tx.Nonce()
-	if m.items[nonce] == nil {
-		heap.Push(m.index, nonce)
-	}
-	m.items[nonce], m.cache = tx, nil
-}
-
-// Forward removes all transactions from the map with a nonce lower than the
-// provided threshold. Every removed transaction is returned for any post-removal
-// maintenance.
-func (m *txSortedMap) Forward(threshold uint64) types.Transactions {
-	var removed types.Transactions
-
-	// Pop off heap items until the threshold is reached
-	for m.index.Len() > 0 && (*m.index)[0] < threshold {
-		nonce := heap.Pop(m.index).(uint64)
-		removed = append(removed, m.items[nonce])
-		delete(m.items, nonce)
-	}
-	// If we had a cached order, shift the front
-	if m.cache != nil {
-		m.cache = m.cache[len(removed):]
-	}
-	return removed
-}
-
-// Filter iterates over the list of transactions and removes all of them for which
-// the specified function evaluates to true.
-func (m *txSortedMap) Filter(filter func(*types.Transaction) bool) types.Transactions {
-	var removed types.Transactions
-
-	// Collect all the transactions to filter out
-	for nonce, tx := range m.items {
-		if filter(tx) {
-			removed = append(removed, tx)
-			delete(m.items, nonce)
-		}
-	}
-	// If transactions were removed, the heap and cache are ruined
-	if len(removed) > 0 {
-		*m.index = make([]uint64, 0, len(m.items))
-		for nonce, _ := range m.items {
-			*m.index = append(*m.index, nonce)
-		}
-		heap.Init(m.index)
-
-		m.cache = nil
-	}
-	return removed
-}
-
-// Cap places a hard limit on the number of items, returning all transactions
-// exceeding that limit.
-func (m *txSortedMap) Cap(threshold int) types.Transactions {
-	// Short circuit if the number of items is under the limit
-	if len(m.items) <= threshold {
-		return nil
-	}
-	// Otherwise gather and drop the highest nonce'd transactions
-	var drops types.Transactions
-
-	sort.Sort(*m.index)
-	for size := len(m.items); size > threshold; size-- {
-		drops = append(drops, m.items[(*m.index)[size-1]])
-		delete(m.items, (*m.index)[size-1])
-	}
-	*m.index = (*m.index)[:threshold]
-	heap.Init(m.index)
-
-	// If we had a cache, shift the back
-	if m.cache != nil {
-		m.cache = m.cache[:len(m.cache)-len(drops)]
-	}
-	return drops
-}
-
-// Remove deletes a transaction from the maintained map, returning whether the
-// transaction was found.
-func (m *txSortedMap) Remove(nonce uint64) bool {
-	// Short circuit if no transaction is present
-	_, ok := m.items[nonce]
-	if !ok {
-		return false
-	}
-	// Otherwise delete the transaction and fix the heap index
-	for i := 0; i < m.index.Len(); i++ {
-		if (*m.index)[i] == nonce {
-			heap.Remove(m.index, i)
-			break
-		}
-	}
-	delete(m.items, nonce)
-	m.cache = nil
-
-	return true
-}
-
-// Ready retrieves a sequentially increasing list of transactions starting at the
-// provided nonce that is ready for processing. The returned transactions will be
-// removed from the list.
-//
-// Note, all transactions with nonces lower than start will also be returned to
-// prevent getting into and invalid state. This is not something that should ever
-// happen but better to be self correcting than failing!
-func (m *txSortedMap) Ready(start uint64) types.Transactions {
-	// Short circuit if no transactions are available
-	if m.index.Len() == 0 || (*m.index)[0] > start {
-		return nil
-	}
-	// Otherwise start accumulating incremental transactions
-	var ready types.Transactions
-	for next := (*m.index)[0]; m.index.Len() > 0 && (*m.index)[0] == next; next++ {
-		ready = append(ready, m.items[next])
-		delete(m.items, next)
-		heap.Pop(m.index)
-	}
-	m.cache = nil
-
-	return ready
-}
-
-// Len returns the length of the transaction map.
-func (m *txSortedMap) Len() int {
-	return len(m.items)
-}
-
-// Flatten creates a nonce-sorted slice of transactions based on the loosely
-// sorted internal representation. The result of the sorting is cached in case
-// it's requested again before any modifications are made to the contents.
-func (m *txSortedMap) Flatten() types.Transactions {
-	// If the sorting was not cached yet, create and cache it
-	if m.cache == nil {
-		m.cache = make(types.Transactions, 0, len(m.items))
-		for _, tx := range m.items {
-			m.cache = append(m.cache, tx)
-		}
-		sort.Sort(types.TxByNonce(m.cache))
-	}
-	// Copy the cache to prevent accidental modifications
-	txs := make(types.Transactions, len(m.cache))
-	copy(txs, m.cache)
-	return txs
-}
-
-// txList is a "list" of transactions belonging to an account, sorted by account
-// nonce. The same type can be used both for storing contiguous transactions for
-// the executable/pending queue; and for storing gapped transactions for the non-
-// executable/future queue, with minor behavoiral changes.
-type txList struct {
-	strict  bool         // Whether nonces are strictly continuous or not
-	txs     *txSortedMap // Heap indexed sorted hash map of the transactions
-	costcap *big.Int     // Price of the highest costing transaction (reset only if exceeds balance)
-}
-
-// newTxList create a new transaction list for maintaining nonce-indexable fast,
-// gapped, sortable transaction lists.
-func newTxList(strict bool) *txList {
-	return &txList{
-		strict:  strict,
-		txs:     newTxSortedMap(),
-		costcap: new(big.Int),
-	}
-}
-
-// Add tries to insert a new transaction into the list, returning whether the
-// transaction was accepted, and if yes, any previous transaction it replaced.
-//
-// If the new transaction is accepted into the list, the lists' cost threshold
-// is also potentially updated.
-func (l *txList) Add(tx *types.Transaction) (bool, *types.Transaction) {
-	// If there's an older better transaction, abort
-	old := l.txs.Get(tx.Nonce())
-	if old != nil && old.GasPrice().Cmp(tx.GasPrice()) >= 0 {
-		return false, nil
-	}
-	// Otherwise overwrite the old transaction with the current one
-	l.txs.Put(tx)
-	if cost := tx.Cost(); l.costcap.Cmp(cost) < 0 {
-		l.costcap = cost
-	}
-	return true, old
-}
-
-// Forward removes all transactions from the list with a nonce lower than the
-// provided threshold. Every removed transaction is returned for any post-removal
-// maintenance.
-func (l *txList) Forward(threshold uint64) types.Transactions {
-	return l.txs.Forward(threshold)
-}
-
-// Filter removes all transactions from the list with a cost higher than the
-// provided threshold. Every removed transaction is returned for any post-removal
-// maintenance. Strict-mode invalidated transactions are also returned.
-//
-// This method uses the cached costcap to quickly decide if there's even a point
-// in calculating all the costs or if the balance covers all. If the threshold is
-// lower than the costcap, the costcap will be reset to a new high after removing
-// expensive the too transactions.
-func (l *txList) Filter(threshold *big.Int) (types.Transactions, types.Transactions) {
-	// If all transactions are below the threshold, short circuit
-	if l.costcap.Cmp(threshold) <= 0 {
-		return nil, nil
-	}
-	l.costcap = new(big.Int).Set(threshold) // Lower the cap to the threshold
-
-	// Filter out all the transactions above the account's funds
-	removed := l.txs.Filter(func(tx *types.Transaction) bool { return tx.Cost().Cmp(threshold) > 0 })
-
-	// If the list was strict, filter anything above the lowest nonce
-	var invalids types.Transactions
-	if l.strict && len(removed) > 0 {
-		lowest := uint64(math.MaxUint64)
-		for _, tx := range removed {
-			if nonce := tx.Nonce(); lowest > nonce {
-				lowest = nonce
-			}
-		}
-		invalids = l.txs.Filter(func(tx *types.Transaction) bool { return tx.Nonce() > lowest })
-	}
-	return removed, invalids
-}
-
-// Cap places a hard limit on the number of items, returning all transactions
-// exceeding that limit.
-func (l *txList) Cap(threshold int) types.Transactions {
-	return l.txs.Cap(threshold)
-}
-
-// Remove deletes a transaction from the maintained list, returning whether the
-// transaction was found, and also returning any transaction invalidated due to
-// the deletion (strict mode only).
-func (l *txList) Remove(tx *types.Transaction) (bool, types.Transactions) {
-	// Remove the transaction from the set
-	nonce := tx.Nonce()
-	if removed := l.txs.Remove(nonce); !removed {
-		return false, nil
-	}
-	// In strict mode, filter out non-executable transactions
-	if l.strict {
-		return true, l.txs.Filter(func(tx *types.Transaction) bool { return tx.Nonce() > nonce })
-	}
-	return true, nil
-}
-
-// Ready retrieves a sequentially increasing list of transactions starting at the
-// provided nonce that is ready for processing. The returned transactions will be
-// removed from the list.
-//
-// Note, all transactions with nonces lower than start will also be returned to
-// prevent getting into and invalid state. This is not something that should ever
-// happen but better to be self correcting than failing!
-func (l *txList) Ready(start uint64) types.Transactions {
-	return l.txs.Ready(start)
-}
-
-// Len returns the length of the transaction list.
-func (l *txList) Len() int {
-	return l.txs.Len()
-}
-
-// Empty returns whether the list of transactions is empty or not.
-func (l *txList) Empty() bool {
-	return l.Len() == 0
-}
-
-// Flatten creates a nonce-sorted slice of transactions based on the loosely
-// sorted internal representation. The result of the sorting is cached in case
-// it's requested again before any modifications are made to the contents.
-func (l *txList) Flatten() types.Transactions {
-	return l.txs.Flatten()
-}

core/tx_list_test.go

@@ -1,52 +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 core
-
-import (
-	"math/big"
-	"math/rand"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
-)
-
-// Tests that transactions can be added to strict lists and list contents and
-// nonce boundaries are correctly maintained.
-func TestStrictTxListAdd(t *testing.T) {
-	// Generate a list of transactions to insert
-	key, _ := crypto.GenerateKey()
-
-	txs := make(types.Transactions, 1024)
-	for i := 0; i < len(txs); i++ {
-		txs[i] = transaction(uint64(i), new(big.Int), key)
-	}
-	// Insert the transactions in a random order
-	list := newTxList(true)
-	for _, v := range rand.Perm(len(txs)) {
-		list.Add(txs[v])
-	}
-	// Verify internal state
-	if len(list.txs.items) != len(txs) {
-		t.Errorf("transaction count mismatch: have %d, want %d", len(list.txs.items), len(txs))
-	}
-	for i, tx := range txs {
-		if list.txs.items[tx.Nonce()] != tx {
-			t.Errorf("item %d: transaction mismatch: have %v, want %v", i, list.txs.items[tx.Nonce()], tx)
-		}
-	}
-}

core/tx_pool.go

@@ -30,8 +30,6 @@ import (
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/logger/glog"
-	"github.com/ethereum/go-ethereum/params"
-	"gopkg.in/karalabe/cookiejar.v2/collections/prque"
 )
 
 var (
@@ -47,13 +45,8 @@ var (
 	ErrNegativeValue      = errors.New("Negative value")
 )
 
-var (
-	minPendingPerAccount = uint64(16)    // Min number of guaranteed transaction slots per address
-	maxPendingTotal      = uint64(4096)  // Max limit of pending transactions from all accounts (soft)
-	maxQueuedPerAccount  = uint64(64)    // Max limit of queued transactions per address
-	maxQueuedInTotal     = uint64(1024)  // Max limit of queued transactions from all accounts
-	maxQueuedLifetime    = 3 * time.Hour // Max amount of time transactions from idle accounts are queued
-	evictionInterval     = time.Minute   // Time interval to check for evictable transactions
+const (
+	maxQueued = 64 // max limit of queued txs per address
 )
 
 type stateFn func() (*state.StateDB, error)
@@ -66,9 +59,7 @@ type stateFn func() (*state.StateDB, error)
 // current state) and future transactions. Transactions move between those
 // two states over time as they are received and processed.
 type TxPool struct {
-	config *params.ChainConfig
-	signer types.Signer
-
+	config       *ChainConfig
 	currentState stateFn // The state function which will allow us to do some pre checks
 	pendingState *state.ManagedState
 	gasLimit     func() *big.Int // The current gas limit function callback
@@ -77,26 +68,19 @@ type TxPool struct {
 	events       event.Subscription
 	localTx      *txSet
 	mu           sync.RWMutex
+	pending      map[common.Hash]*types.Transaction // processable transactions
+	queue        map[common.Address]map[common.Hash]*types.Transaction
 
-	pending map[common.Address]*txList         // All currently processable transactions
-	queue   map[common.Address]*txList         // Queued but non-processable transactions
-	all     map[common.Hash]*types.Transaction // All transactions to allow lookups
-	beats   map[common.Address]time.Time       // Last heartbeat from each known account
-
-	wg   sync.WaitGroup // for shutdown sync
-	quit chan struct{}
+	wg sync.WaitGroup // for shutdown sync
 
 	homestead bool
 }
 
-func NewTxPool(config *params.ChainConfig, eventMux *event.TypeMux, currentStateFn stateFn, gasLimitFn func() *big.Int) *TxPool {
+func NewTxPool(config *ChainConfig, eventMux *event.TypeMux, currentStateFn stateFn, gasLimitFn func() *big.Int) *TxPool {
 	pool := &TxPool{
 		config:       config,
-		signer:       types.NewEIP155Signer(config.ChainId),
-		pending:      make(map[common.Address]*txList),
-		queue:        make(map[common.Address]*txList),
-		all:          make(map[common.Hash]*types.Transaction),
-		beats:        make(map[common.Address]time.Time),
+		pending:      make(map[common.Hash]*types.Transaction),
+		queue:        make(map[common.Address]map[common.Hash]*types.Transaction),
 		eventMux:     eventMux,
 		currentState: currentStateFn,
 		gasLimit:     gasLimitFn,
@@ -104,12 +88,10 @@ func NewTxPool(config *params.ChainConfig, eventMux *event.TypeMux, currentState
 		pendingState: nil,
 		localTx:      newTxSet(),
 		events:       eventMux.Subscribe(ChainHeadEvent{}, GasPriceChanged{}, RemovedTransactionEvent{}),
-		quit:         make(chan struct{}),
 	}
 
-	pool.wg.Add(2)
+	pool.wg.Add(1)
 	go pool.eventLoop()
-	go pool.expirationLoop()
 
 	return pool
 }
@@ -135,7 +117,7 @@ func (pool *TxPool) eventLoop() {
 			pool.minGasPrice = ev.Price
 			pool.mu.Unlock()
 		case RemovedTransactionEvent:
-			pool.AddBatch(ev.Txs)
+			pool.AddTransactions(ev.Txs)
 		}
 	}
 }
@@ -143,12 +125,12 @@ func (pool *TxPool) eventLoop() {
 func (pool *TxPool) resetState() {
 	currentState, err := pool.currentState()
 	if err != nil {
-		glog.V(logger.Error).Infof("Failed to get current state: %v", err)
+		glog.V(logger.Info).Infoln("failed to get current state: %v", err)
 		return
 	}
 	managedState := state.ManageState(currentState)
 	if err != nil {
-		glog.V(logger.Error).Infof("Failed to get managed state: %v", err)
+		glog.V(logger.Info).Infoln("failed to get managed state: %v", err)
 		return
 	}
 	pool.pendingState = managedState
@@ -157,21 +139,26 @@ func (pool *TxPool) resetState() {
 	// any transactions that have been included in the block or
 	// have been invalidated because of another transaction (e.g.
 	// higher gas price)
-	pool.demoteUnexecutables()
+	pool.validatePool()
 
-	// Update all accounts to the latest known pending nonce
-	for addr, list := range pool.pending {
-		txs := list.Flatten() // Heavy but will be cached and is needed by the miner anyway
-		pool.pendingState.SetNonce(addr, txs[len(txs)-1].Nonce()+1)
+	// Loop over the pending transactions and base the nonce of the new
+	// pending transaction set.
+	for _, tx := range pool.pending {
+		if addr, err := tx.From(); err == nil {
+			// Set the nonce. Transaction nonce can never be lower
+			// than the state nonce; validatePool took care of that.
+			if pool.pendingState.GetNonce(addr) <= tx.Nonce() {
+				pool.pendingState.SetNonce(addr, tx.Nonce()+1)
+			}
+		}
 	}
 	// Check the queue and move transactions over to the pending if possible
 	// or remove those that have become invalid
-	pool.promoteExecutables()
+	pool.checkQueue()
 }
 
 func (pool *TxPool) Stop() {
 	pool.events.Unsubscribe()
-	close(pool.quit)
 	pool.wg.Wait()
 	glog.V(logger.Info).Infoln("Transaction pool stopped")
 }
@@ -183,58 +170,47 @@ func (pool *TxPool) State() *state.ManagedState {
 	return pool.pendingState
 }
 
-// Stats retrieves the current pool stats, namely the number of pending and the
-// number of queued (non-executable) transactions.
 func (pool *TxPool) Stats() (pending int, queued int) {
 	pool.mu.RLock()
 	defer pool.mu.RUnlock()
 
-	for _, list := range pool.pending {
-		pending += list.Len()
-	}
-	for _, list := range pool.queue {
-		queued += list.Len()
+	pending = len(pool.pending)
+	for _, txs := range pool.queue {
+		queued += len(txs)
 	}
 	return
 }
 
 // Content retrieves the data content of the transaction pool, returning all the
-// pending as well as queued transactions, grouped by account and sorted by nonce.
-func (pool *TxPool) Content() (map[common.Address]types.Transactions, map[common.Address]types.Transactions) {
+// pending as well as queued transactions, grouped by account and nonce.
+func (pool *TxPool) Content() (map[common.Address]map[uint64][]*types.Transaction, map[common.Address]map[uint64][]*types.Transaction) {
 	pool.mu.RLock()
 	defer pool.mu.RUnlock()
 
-	pending := make(map[common.Address]types.Transactions)
-	for addr, list := range pool.pending {
-		pending[addr] = list.Flatten()
+	// Retrieve all the pending transactions and sort by account and by nonce
+	pending := make(map[common.Address]map[uint64][]*types.Transaction)
+	for _, tx := range pool.pending {
+		account, _ := tx.From()
+
+		owned, ok := pending[account]
+		if !ok {
+			owned = make(map[uint64][]*types.Transaction)
+			pending[account] = owned
+		}
+		owned[tx.Nonce()] = append(owned[tx.Nonce()], tx)
 	}
-	queued := make(map[common.Address]types.Transactions)
-	for addr, list := range pool.queue {
-		queued[addr] = list.Flatten()
+	// Retrieve all the queued transactions and sort by account and by nonce
+	queued := make(map[common.Address]map[uint64][]*types.Transaction)
+	for account, txs := range pool.queue {
+		owned := make(map[uint64][]*types.Transaction)
+		for _, tx := range txs {
+			owned[tx.Nonce()] = append(owned[tx.Nonce()], tx)
+		}
+		queued[account] = owned
 	}
 	return pending, queued
 }
 
-// Pending retrieves all currently processable transactions, groupped by origin
-// account and sorted by nonce. The returned transaction set is a copy and can be
-// freely modified by calling code.
-func (pool *TxPool) Pending() map[common.Address]types.Transactions {
-	pool.mu.Lock()
-	defer pool.mu.Unlock()
-
-	// check queue first
-	pool.promoteExecutables()
-
-	// invalidate any txs
-	pool.demoteUnexecutables()
-
-	pending := make(map[common.Address]types.Transactions)
-	for addr, list := range pool.pending {
-		pending[addr] = list.Flatten()
-	}
-	return pending
-}
-
 // SetLocal marks a transaction as local, skipping gas price
 //  check against local miner minimum in the future
 func (pool *TxPool) SetLocal(tx *types.Transaction) {
@@ -257,7 +233,6 @@ func (pool *TxPool) validateTx(tx *types.Transaction) error {
 		return err
 	}
 
-	tx.SetSigner(pool.signer)
 	from, err := tx.From()
 	if err != nil {
 		return ErrInvalidSender
@@ -265,7 +240,7 @@ func (pool *TxPool) validateTx(tx *types.Transaction) error {
 
 	// Make sure the account exist. Non existent accounts
 	// haven't got funds and well therefor never pass.
-	if !currentState.Exist(from) {
+	if !currentState.HasAccount(from) {
 		return ErrNonExistentAccount
 	}
 
@@ -301,400 +276,312 @@ func (pool *TxPool) validateTx(tx *types.Transaction) error {
 	return nil
 }
 
-// add validates a transaction and inserts it into the non-executable queue for
-// later pending promotion and execution.
-func (pool *TxPool) add(tx *types.Transaction) error {
-	// If the transaction is alreayd known, discard it
+// validate and queue transactions.
+func (self *TxPool) add(tx *types.Transaction) error {
 	hash := tx.Hash()
-	if pool.all[hash] != nil {
-		return fmt.Errorf("Known transaction: %x", hash[:4])
+
+	if self.pending[hash] != nil {
+		return fmt.Errorf("Known transaction (%x)", hash[:4])
 	}
-	// Otherwise ensure basic validation passes and queue it up
-	if err := pool.validateTx(tx); err != nil {
+	err := self.validateTx(tx)
+	if err != nil {
 		return err
 	}
-	pool.enqueueTx(hash, tx)
+	self.queueTx(hash, tx)
 
-	// Print a log message if low enough level is set
 	if glog.V(logger.Debug) {
-		rcpt := "[NEW_CONTRACT]"
+		var toname string
 		if to := tx.To(); to != nil {
-			rcpt = common.Bytes2Hex(to[:4])
+			toname = common.Bytes2Hex(to[:4])
+		} else {
+			toname = "[NEW_CONTRACT]"
 		}
-		from, _ := tx.From() // from already verified during tx validation
-		glog.Infof("(t) 0x%x => %s (%v) %x\n", from[:4], rcpt, tx.Value, hash)
+		// we can ignore the error here because From is
+		// verified in ValidateTransaction.
+		f, _ := tx.From()
+		from := common.Bytes2Hex(f[:4])
+		glog.Infof("(t) %x => %s (%v) %x\n", from, toname, tx.Value, hash)
 	}
+
 	return nil
 }
 
-// enqueueTx inserts a new transaction into the non-executable transaction queue.
-//
-// Note, this method assumes the pool lock is held!
-func (pool *TxPool) enqueueTx(hash common.Hash, tx *types.Transaction) {
-	// Try to insert the transaction into the future queue
+// queueTx will queue an unknown transaction
+func (self *TxPool) queueTx(hash common.Hash, tx *types.Transaction) {
 	from, _ := tx.From() // already validated
-	if pool.queue[from] == nil {
-		pool.queue[from] = newTxList(false)
+	if self.queue[from] == nil {
+		self.queue[from] = make(map[common.Hash]*types.Transaction)
 	}
-	inserted, old := pool.queue[from].Add(tx)
-	if !inserted {
-		return // An older transaction was better, discard this
-	}
-	// Discard any previous transaction and mark this
-	if old != nil {
-		delete(pool.all, old.Hash())
-	}
-	pool.all[hash] = tx
+	self.queue[from][hash] = tx
 }
 
-// promoteTx adds a transaction to the pending (processable) list of transactions.
-//
-// Note, this method assumes the pool lock is held!
-func (pool *TxPool) promoteTx(addr common.Address, hash common.Hash, tx *types.Transaction) {
-	// Init delayed since tx pool could have been started before any state sync
+// addTx will add a transaction to the pending (processable queue) list of transactions
+func (pool *TxPool) addTx(hash common.Hash, addr common.Address, tx *types.Transaction) {
+	// init delayed since tx pool could have been started before any state sync
 	if pool.pendingState == nil {
 		pool.resetState()
 	}
-	// Try to insert the transaction into the pending queue
-	if pool.pending[addr] == nil {
-		pool.pending[addr] = newTxList(true)
-	}
-	list := pool.pending[addr]
 
-	inserted, old := list.Add(tx)
-	if !inserted {
-		// An older transaction was better, discard this
-		delete(pool.all, hash)
-		return
-	}
-	// Otherwise discard any previous transaction and mark this
-	if old != nil {
-		delete(pool.all, old.Hash())
-	}
-	pool.all[hash] = tx // Failsafe to work around direct pending inserts (tests)
+	if _, ok := pool.pending[hash]; !ok {
+		pool.pending[hash] = tx
 
-	// Set the potentially new pending nonce and notify any subsystems of the new tx
-	pool.beats[addr] = time.Now()
-	pool.pendingState.SetNonce(addr, tx.Nonce()+1)
-	go pool.eventMux.Post(TxPreEvent{tx})
+		// Increment the nonce on the pending state. This can only happen if
+		// the nonce is +1 to the previous one.
+		pool.pendingState.SetNonce(addr, tx.Nonce()+1)
+		// Notify the subscribers. This event is posted in a goroutine
+		// because it's possible that somewhere during the post "Remove transaction"
+		// gets called which will then wait for the global tx pool lock and deadlock.
+		go pool.eventMux.Post(TxPreEvent{tx})
+	}
 }
 
 // Add queues a single transaction in the pool if it is valid.
-func (pool *TxPool) Add(tx *types.Transaction) error {
-	pool.mu.Lock()
-	defer pool.mu.Unlock()
+func (self *TxPool) Add(tx *types.Transaction) error {
+	self.mu.Lock()
+	defer self.mu.Unlock()
 
-	if err := pool.add(tx); err != nil {
+	if err := self.add(tx); err != nil {
 		return err
 	}
-	pool.promoteExecutables()
-
+	self.checkQueue()
 	return nil
 }
 
-// AddBatch attempts to queue a batch of transactions.
-func (pool *TxPool) AddBatch(txs []*types.Transaction) {
-	pool.mu.Lock()
-	defer pool.mu.Unlock()
+// AddTransactions attempts to queue all valid transactions in txs.
+func (self *TxPool) AddTransactions(txs []*types.Transaction) {
+	self.mu.Lock()
+	defer self.mu.Unlock()
 
 	for _, tx := range txs {
-		if err := pool.add(tx); err != nil {
+		if err := self.add(tx); err != nil {
 			glog.V(logger.Debug).Infoln("tx error:", err)
+		} else {
+			h := tx.Hash()
+			glog.V(logger.Debug).Infof("tx %x\n", h[:4])
 		}
 	}
-	pool.promoteExecutables()
+
+	// check and validate the queue
+	self.checkQueue()
 }
 
-// Get returns a transaction if it is contained in the pool
+// GetTransaction returns a transaction if it is contained in the pool
 // and nil otherwise.
-func (pool *TxPool) Get(hash common.Hash) *types.Transaction {
-	pool.mu.RLock()
-	defer pool.mu.RUnlock()
+func (tp *TxPool) GetTransaction(hash common.Hash) *types.Transaction {
+	tp.mu.RLock()
+	defer tp.mu.RUnlock()
 
-	return pool.all[hash]
+	// check the txs first
+	if tx, ok := tp.pending[hash]; ok {
+		return tx
+	}
+	// check queue
+	for _, txs := range tp.queue {
+		if tx, ok := txs[hash]; ok {
+			return tx
+		}
+	}
+	return nil
 }
 
-// Remove removes the transaction with the given hash from the pool.
-func (pool *TxPool) Remove(hash common.Hash) {
+// GetTransactions returns all currently processable transactions.
+// The returned slice may be modified by the caller.
+func (self *TxPool) GetTransactions() (txs types.Transactions) {
+	self.mu.Lock()
+	defer self.mu.Unlock()
+
+	// check queue first
+	self.checkQueue()
+	// invalidate any txs
+	self.validatePool()
+
+	txs = make(types.Transactions, len(self.pending))
+	i := 0
+	for _, tx := range self.pending {
+		txs[i] = tx
+		i++
+	}
+	return txs
+}
+
+// GetQueuedTransactions returns all non-processable transactions.
+func (self *TxPool) GetQueuedTransactions() types.Transactions {
+	self.mu.RLock()
+	defer self.mu.RUnlock()
+
+	var ret types.Transactions
+	for _, txs := range self.queue {
+		for _, tx := range txs {
+			ret = append(ret, tx)
+		}
+	}
+	sort.Sort(types.TxByNonce(ret))
+	return ret
+}
+
+// RemoveTransactions removes all given transactions from the pool.
+func (self *TxPool) RemoveTransactions(txs types.Transactions) {
+	self.mu.Lock()
+	defer self.mu.Unlock()
+	for _, tx := range txs {
+		self.removeTx(tx.Hash())
+	}
+}
+
+// RemoveTx removes the transaction with the given hash from the pool.
+func (pool *TxPool) RemoveTx(hash common.Hash) {
 	pool.mu.Lock()
 	defer pool.mu.Unlock()
-
 	pool.removeTx(hash)
 }
 
-// RemoveBatch removes all given transactions from the pool.
-func (pool *TxPool) RemoveBatch(txs types.Transactions) {
-	pool.mu.Lock()
-	defer pool.mu.Unlock()
-
-	for _, tx := range txs {
-		pool.removeTx(tx.Hash())
-	}
-}
-
-// removeTx removes a single transaction from the queue, moving all subsequent
-// transactions back to the future queue.
 func (pool *TxPool) removeTx(hash common.Hash) {
-	// Fetch the transaction we wish to delete
-	tx, ok := pool.all[hash]
-	if !ok {
-		return
-	}
-	addr, _ := tx.From() // already validated during insertion
-
-	// Remove it from the list of known transactions
-	delete(pool.all, hash)
-
-	// Remove the transaction from the pending lists and reset the account nonce
-	if pending := pool.pending[addr]; pending != nil {
-		if removed, invalids := pending.Remove(tx); removed {
-			// If no more transactions are left, remove the list
-			if pending.Empty() {
-				delete(pool.pending, addr)
-				delete(pool.beats, addr)
+	// delete from pending pool
+	delete(pool.pending, hash)
+	// delete from queue
+	for address, txs := range pool.queue {
+		if _, ok := txs[hash]; ok {
+			if len(txs) == 1 {
+				// if only one tx, remove entire address entry.
+				delete(pool.queue, address)
 			} else {
-				// Otherwise postpone any invalidated transactions
-				for _, tx := range invalids {
-					pool.enqueueTx(tx.Hash(), tx)
-				}
+				delete(txs, hash)
 			}
-			// Update the account nonce if needed
-			if nonce := tx.Nonce(); pool.pendingState.GetNonce(addr) > nonce {
-				pool.pendingState.SetNonce(addr, tx.Nonce())
-			}
-		}
-	}
-	// Transaction is in the future queue
-	if future := pool.queue[addr]; future != nil {
-		future.Remove(tx)
-		if future.Empty() {
-			delete(pool.queue, addr)
+			break
 		}
 	}
 }
 
-// promoteExecutables moves transactions that have become processable from the
-// future queue to the set of pending transactions. During this process, all
-// invalidated transactions (low nonce, low balance) are deleted.
-func (pool *TxPool) promoteExecutables() {
-	// Init delayed since tx pool could have been started before any state sync
+// checkQueue moves transactions that have become processable to main pool.
+func (pool *TxPool) checkQueue() {
+	// init delayed since tx pool could have been started before any state sync
 	if pool.pendingState == nil {
 		pool.resetState()
 	}
-	// Retrieve the current state to allow nonce and balance checking
-	state, err := pool.currentState()
-	if err != nil {
-		glog.Errorf("Could not get current state: %v", err)
-		return
-	}
-	// Iterate over all accounts and promote any executable transactions
-	queued := uint64(0)
-	for addr, list := range pool.queue {
-		// Drop all transactions that are deemed too old (low nonce)
-		for _, tx := range list.Forward(state.GetNonce(addr)) {
-			if glog.V(logger.Core) {
-				glog.Infof("Removed old queued transaction: %v", tx)
-			}
-			delete(pool.all, tx.Hash())
-		}
-		// Drop all transactions that are too costly (low balance)
-		drops, _ := list.Filter(state.GetBalance(addr))
-		for _, tx := range drops {
-			if glog.V(logger.Core) {
-				glog.Infof("Removed unpayable queued transaction: %v", tx)
-			}
-			delete(pool.all, tx.Hash())
-		}
-		// Gather all executable transactions and promote them
-		for _, tx := range list.Ready(pool.pendingState.GetNonce(addr)) {
-			if glog.V(logger.Core) {
-				glog.Infof("Promoting queued transaction: %v", tx)
-			}
-			pool.promoteTx(addr, tx.Hash(), tx)
-		}
-		// Drop all transactions over the allowed limit
-		for _, tx := range list.Cap(int(maxQueuedPerAccount)) {
-			if glog.V(logger.Core) {
-				glog.Infof("Removed cap-exceeding queued transaction: %v", tx)
-			}
-			delete(pool.all, tx.Hash())
-		}
-		queued += uint64(list.Len())
 
-		// Delete the entire queue entry if it became empty.
-		if list.Empty() {
-			delete(pool.queue, addr)
+	var promote txQueue
+	for address, txs := range pool.queue {
+		currentState, err := pool.currentState()
+		if err != nil {
+			glog.Errorf("could not get current state: %v", err)
+			return
 		}
-	}
-	// If the pending limit is overflown, start equalizing allowances
-	pending := uint64(0)
-	for _, list := range pool.pending {
-		pending += uint64(list.Len())
-	}
-	if pending > maxPendingTotal {
-		// Assemble a spam order to penalize large transactors first
-		spammers := prque.New()
-		for addr, list := range pool.pending {
-			// Only evict transactions from high rollers
-			if uint64(list.Len()) > minPendingPerAccount {
-				// Skip local accounts as pools should maintain backlogs for themselves
-				for _, tx := range list.txs.items {
-					if !pool.localTx.contains(tx.Hash()) {
-						spammers.Push(addr, float32(list.Len()))
-					}
-					break // Checking on transaction for locality is enough
+		balance := currentState.GetBalance(address)
+
+		var (
+			guessedNonce = pool.pendingState.GetNonce(address) // nonce currently kept by the tx pool (pending state)
+			trueNonce    = currentState.GetNonce(address)      // nonce known by the last state
+		)
+		promote = promote[:0]
+		for hash, tx := range txs {
+			// Drop processed or out of fund transactions
+			if tx.Nonce() < trueNonce || balance.Cmp(tx.Cost()) < 0 {
+				if glog.V(logger.Core) {
+					glog.Infof("removed tx (%v) from pool queue: low tx nonce or out of funds\n", tx)
 				}
-			}
-		}
-		// Gradually drop transactions from offenders
-		offenders := []common.Address{}
-		for pending > maxPendingTotal && !spammers.Empty() {
-			// Retrieve the next offender if not local address
-			offender, _ := spammers.Pop()
-			offenders = append(offenders, offender.(common.Address))
-
-			// Equalize balances until all the same or below threshold
-			if len(offenders) > 1 {
-				// Calculate the equalization threshold for all current offenders
-				threshold := pool.pending[offender.(common.Address)].Len()
-
-				// Iteratively reduce all offenders until below limit or threshold reached
-				for pending > maxPendingTotal && pool.pending[offenders[len(offenders)-2]].Len() > threshold {
-					for i := 0; i < len(offenders)-1; i++ {
-						list := pool.pending[offenders[i]]
-						list.Cap(list.Len() - 1)
-						pending--
-					}
-				}
-			}
-		}
-		// If still above threshold, reduce to limit or min allowance
-		if pending > maxPendingTotal && len(offenders) > 0 {
-			for pending > maxPendingTotal && uint64(pool.pending[offenders[len(offenders)-1]].Len()) > minPendingPerAccount {
-				for _, addr := range offenders {
-					list := pool.pending[addr]
-					list.Cap(list.Len() - 1)
-					pending--
-				}
-			}
-		}
-	}
-	// If we've queued more transactions than the hard limit, drop oldest ones
-	if queued > maxQueuedInTotal {
-		// Sort all accounts with queued transactions by heartbeat
-		addresses := make(addresssByHeartbeat, 0, len(pool.queue))
-		for addr, _ := range pool.queue {
-			addresses = append(addresses, addressByHeartbeat{addr, pool.beats[addr]})
-		}
-		sort.Sort(addresses)
-
-		// Drop transactions until the total is below the limit
-		for drop := queued - maxQueuedInTotal; drop > 0; {
-			addr := addresses[len(addresses)-1]
-			list := pool.queue[addr.address]
-
-			addresses = addresses[:len(addresses)-1]
-
-			// Drop all transactions if they are less than the overflow
-			if size := uint64(list.Len()); size <= drop {
-				for _, tx := range list.Flatten() {
-					pool.removeTx(tx.Hash())
-				}
-				drop -= size
+				delete(txs, hash)
 				continue
 			}
-			// Otherwise drop only last few transactions
-			txs := list.Flatten()
-			for i := len(txs) - 1; i >= 0 && drop > 0; i-- {
-				pool.removeTx(txs[i].Hash())
-				drop--
+			// Collect the remaining transactions for the next pass.
+			promote = append(promote, txQueueEntry{hash, address, tx})
+		}
+		// Find the next consecutive nonce range starting at the current account nonce,
+		// pushing the guessed nonce forward if we add consecutive transactions.
+		sort.Sort(promote)
+		for i, entry := range promote {
+			// If we reached a gap in the nonces, enforce transaction limit and stop
+			if entry.Nonce() > guessedNonce {
+				if len(promote)-i > maxQueued {
+					if glog.V(logger.Debug) {
+						glog.Infof("Queued tx limit exceeded for %s. Tx %s removed\n", common.PP(address[:]), common.PP(entry.hash[:]))
+					}
+					for _, drop := range promote[i+maxQueued:] {
+						delete(txs, drop.hash)
+					}
+				}
+				break
 			}
+			// Otherwise promote the transaction and move the guess nonce if needed
+			pool.addTx(entry.hash, address, entry.Transaction)
+			delete(txs, entry.hash)
+
+			if entry.Nonce() == guessedNonce {
+				guessedNonce++
+			}
+		}
+		// Delete the entire queue entry if it became empty.
+		if len(txs) == 0 {
+			delete(pool.queue, address)
 		}
 	}
 }
 
-// demoteUnexecutables removes invalid and processed transactions from the pools
-// executable/pending queue and any subsequent transactions that become unexecutable
-// are moved back into the future queue.
-func (pool *TxPool) demoteUnexecutables() {
-	// Retrieve the current state to allow nonce and balance checking
+// validatePool removes invalid and processed transactions from the main pool.
+// If a transaction is removed for being invalid (e.g. out of funds), all sub-
+// sequent (Still valid) transactions are moved back into the future queue. This
+// is important to prevent a drained account from DOSing the network with non
+// executable transactions.
+func (pool *TxPool) validatePool() {
 	state, err := pool.currentState()
 	if err != nil {
 		glog.V(logger.Info).Infoln("failed to get current state: %v", err)
 		return
 	}
-	// Iterate over all accounts and demote any non-executable transactions
-	for addr, list := range pool.pending {
-		nonce := state.GetNonce(addr)
+	balanceCache := make(map[common.Address]*big.Int)
 
-		// Drop all transactions that are deemed too old (low nonce)
-		for _, tx := range list.Forward(nonce) {
+	// Clean up the pending pool, accumulating invalid nonces
+	gaps := make(map[common.Address]uint64)
+
+	for hash, tx := range pool.pending {
+		sender, _ := tx.From() // err already checked
+
+		// Perform light nonce and balance validation
+		balance := balanceCache[sender]
+		if balance == nil {
+			balance = state.GetBalance(sender)
+			balanceCache[sender] = balance
+		}
+		if past := state.GetNonce(sender) > tx.Nonce(); past || balance.Cmp(tx.Cost()) < 0 {
+			// Remove an already past it invalidated transaction
 			if glog.V(logger.Core) {
-				glog.Infof("Removed old pending transaction: %v", tx)
+				glog.Infof("removed tx (%v) from pool: low tx nonce or out of funds\n", tx)
 			}
-			delete(pool.all, tx.Hash())
-		}
-		// Drop all transactions that are too costly (low balance), and queue any invalids back for later
-		drops, invalids := list.Filter(state.GetBalance(addr))
-		for _, tx := range drops {
-			if glog.V(logger.Core) {
-				glog.Infof("Removed unpayable pending transaction: %v", tx)
-			}
-			delete(pool.all, tx.Hash())
-		}
-		for _, tx := range invalids {
-			if glog.V(logger.Core) {
-				glog.Infof("Demoting pending transaction: %v", tx)
-			}
-			pool.enqueueTx(tx.Hash(), tx)
-		}
-		// Delete the entire queue entry if it became empty.
-		if list.Empty() {
-			delete(pool.pending, addr)
-			delete(pool.beats, addr)
-		}
-	}
-}
+			delete(pool.pending, hash)
 
-// expirationLoop is a loop that periodically iterates over all accounts with
-// queued transactions and drop all that have been inactive for a prolonged amount
-// of time.
-func (pool *TxPool) expirationLoop() {
-	defer pool.wg.Done()
-
-	evict := time.NewTicker(evictionInterval)
-	defer evict.Stop()
-
-	for {
-		select {
-		case <-evict.C:
-			pool.mu.Lock()
-			for addr := range pool.queue {
-				if time.Since(pool.beats[addr]) > maxQueuedLifetime {
-					for _, tx := range pool.queue[addr].Flatten() {
-						pool.removeTx(tx.Hash())
-					}
+			// Track the smallest invalid nonce to postpone subsequent transactions
+			if !past {
+				if prev, ok := gaps[sender]; !ok || tx.Nonce() < prev {
+					gaps[sender] = tx.Nonce()
 				}
 			}
-			pool.mu.Unlock()
-
-		case <-pool.quit:
-			return
+		}
+	}
+	// Move all transactions after a gap back to the future queue
+	if len(gaps) > 0 {
+		for hash, tx := range pool.pending {
+			sender, _ := tx.From()
+			if gap, ok := gaps[sender]; ok && tx.Nonce() >= gap {
+				if glog.V(logger.Core) {
+					glog.Infof("postponed tx (%v) due to introduced gap\n", tx)
+				}
+				pool.queueTx(hash, tx)
+				delete(pool.pending, hash)
+			}
 		}
 	}
 }
 
-// addressByHeartbeat is an account address tagged with its last activity timestamp.
-type addressByHeartbeat struct {
-	address   common.Address
-	heartbeat time.Time
+type txQueue []txQueueEntry
+
+type txQueueEntry struct {
+	hash common.Hash
+	addr common.Address
+	*types.Transaction
 }
 
-type addresssByHeartbeat []addressByHeartbeat
-
-func (a addresssByHeartbeat) Len() int           { return len(a) }
-func (a addresssByHeartbeat) Less(i, j int) bool { return a[i].heartbeat.Before(a[j].heartbeat) }
-func (a addresssByHeartbeat) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (q txQueue) Len() int           { return len(q) }
+func (q txQueue) Swap(i, j int)      { q[i], q[j] = q[j], q[i] }
+func (q txQueue) Less(i, j int) bool { return q[i].Nonce() < q[j].Nonce() }
 
 // txSet represents a set of transaction hashes in which entries
 //  are automatically dropped after txSetDuration time

core/tx_pool_test.go

@@ -19,9 +19,7 @@ package core
 import (
 	"crypto/ecdsa"
 	"math/big"
-	"math/rand"
 	"testing"
-	"time"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/state"
@@ -40,10 +38,10 @@ func setupTxPool() (*TxPool, *ecdsa.PrivateKey) {
 	db, _ := ethdb.NewMemDatabase()
 	statedb, _ := state.New(common.Hash{}, db)
 
+	var m event.TypeMux
 	key, _ := crypto.GenerateKey()
-	newPool := NewTxPool(testChainConfig(), new(event.TypeMux), func() (*state.StateDB, error) { return statedb, nil }, func() *big.Int { return big.NewInt(1000000) })
+	newPool := NewTxPool(testChainConfig(), &m, func() (*state.StateDB, error) { return statedb, nil }, func() *big.Int { return big.NewInt(1000000) })
 	newPool.resetState()
-
 	return newPool, key
 }
 
@@ -93,9 +91,9 @@ func TestTransactionQueue(t *testing.T) {
 	from, _ := tx.From()
 	currentState, _ := pool.currentState()
 	currentState.AddBalance(from, big.NewInt(1000))
-	pool.enqueueTx(tx.Hash(), tx)
+	pool.queueTx(tx.Hash(), tx)
 
-	pool.promoteExecutables()
+	pool.checkQueue()
 	if len(pool.pending) != 1 {
 		t.Error("expected valid txs to be 1 is", len(pool.pending))
 	}
@@ -103,14 +101,14 @@ func TestTransactionQueue(t *testing.T) {
 	tx = transaction(1, big.NewInt(100), key)
 	from, _ = tx.From()
 	currentState.SetNonce(from, 2)
-	pool.enqueueTx(tx.Hash(), tx)
-	pool.promoteExecutables()
-	if _, ok := pool.pending[from].txs.items[tx.Nonce()]; ok {
+	pool.queueTx(tx.Hash(), tx)
+	pool.checkQueue()
+	if _, ok := pool.pending[tx.Hash()]; ok {
 		t.Error("expected transaction to be in tx pool")
 	}
 
-	if len(pool.queue) > 0 {
-		t.Error("expected transaction queue to be empty. is", len(pool.queue))
+	if len(pool.queue[from]) > 0 {
+		t.Error("expected transaction queue to be empty. is", len(pool.queue[from]))
 	}
 
 	pool, key = setupTxPool()
@@ -120,17 +118,17 @@ func TestTransactionQueue(t *testing.T) {
 	from, _ = tx1.From()
 	currentState, _ = pool.currentState()
 	currentState.AddBalance(from, big.NewInt(1000))
-	pool.enqueueTx(tx1.Hash(), tx1)
-	pool.enqueueTx(tx2.Hash(), tx2)
-	pool.enqueueTx(tx3.Hash(), tx3)
+	pool.queueTx(tx1.Hash(), tx1)
+	pool.queueTx(tx2.Hash(), tx2)
+	pool.queueTx(tx3.Hash(), tx3)
 
-	pool.promoteExecutables()
+	pool.checkQueue()
 
 	if len(pool.pending) != 1 {
 		t.Error("expected tx pool to be 1, got", len(pool.pending))
 	}
-	if pool.queue[from].Len() != 2 {
-		t.Error("expected len(queue) == 2, got", pool.queue[from].Len())
+	if len(pool.queue[from]) != 2 {
+		t.Error("expected len(queue) == 2, got", len(pool.queue[from]))
 	}
 }
 
@@ -140,21 +138,24 @@ func TestRemoveTx(t *testing.T) {
 	from, _ := tx.From()
 	currentState, _ := pool.currentState()
 	currentState.AddBalance(from, big.NewInt(1))
-
-	pool.enqueueTx(tx.Hash(), tx)
-	pool.promoteTx(from, tx.Hash(), tx)
+	pool.queueTx(tx.Hash(), tx)
+	pool.addTx(tx.Hash(), from, tx)
 	if len(pool.queue) != 1 {
 		t.Error("expected queue to be 1, got", len(pool.queue))
 	}
+
 	if len(pool.pending) != 1 {
-		t.Error("expected pending to be 1, got", len(pool.pending))
+		t.Error("expected txs to be 1, got", len(pool.pending))
 	}
-	pool.Remove(tx.Hash())
+
+	pool.RemoveTx(tx.Hash())
+
 	if len(pool.queue) > 0 {
 		t.Error("expected queue to be 0, got", len(pool.queue))
 	}
+
 	if len(pool.pending) > 0 {
-		t.Error("expected pending to be 0, got", len(pool.pending))
+		t.Error("expected txs to be 0, got", len(pool.pending))
 	}
 }
 
@@ -187,7 +188,7 @@ func TestTransactionChainFork(t *testing.T) {
 	if err := pool.add(tx); err != nil {
 		t.Error("didn't expect error", err)
 	}
-	pool.RemoveBatch([]*types.Transaction{tx})
+	pool.RemoveTransactions([]*types.Transaction{tx})
 
 	// reset the pool's internal state
 	resetState()
@@ -209,38 +210,18 @@ func TestTransactionDoubleNonce(t *testing.T) {
 	}
 	resetState()
 
-	tx1, _ := types.NewTransaction(0, common.Address{}, big.NewInt(100), big.NewInt(100000), big.NewInt(1), nil).SignECDSA(key)
-	tx2, _ := types.NewTransaction(0, common.Address{}, big.NewInt(100), big.NewInt(1000000), big.NewInt(2), nil).SignECDSA(key)
-	tx3, _ := types.NewTransaction(0, common.Address{}, big.NewInt(100), big.NewInt(1000000), big.NewInt(1), nil).SignECDSA(key)
-
-	// Add the first two transaction, ensure higher priced stays only
-	if err := pool.add(tx1); err != nil {
+	tx := transaction(0, big.NewInt(100000), key)
+	tx2 := transaction(0, big.NewInt(1000000), key)
+	if err := pool.add(tx); err != nil {
 		t.Error("didn't expect error", err)
 	}
 	if err := pool.add(tx2); err != nil {
 		t.Error("didn't expect error", err)
 	}
-	pool.promoteExecutables()
-	if pool.pending[addr].Len() != 1 {
-		t.Error("expected 1 pending transactions, got", pool.pending[addr].Len())
-	}
-	if tx := pool.pending[addr].txs.items[0]; tx.Hash() != tx2.Hash() {
-		t.Errorf("transaction mismatch: have %x, want %x", tx.Hash(), tx2.Hash())
-	}
-	// Add the thid transaction and ensure it's not saved (smaller price)
-	if err := pool.add(tx3); err != nil {
-		t.Error("didn't expect error", err)
-	}
-	pool.promoteExecutables()
-	if pool.pending[addr].Len() != 1 {
-		t.Error("expected 1 pending transactions, got", pool.pending[addr].Len())
-	}
-	if tx := pool.pending[addr].txs.items[0]; tx.Hash() != tx2.Hash() {
-		t.Errorf("transaction mismatch: have %x, want %x", tx.Hash(), tx2.Hash())
-	}
-	// Ensure the total transaction count is correct
-	if len(pool.all) != 1 {
-		t.Error("expected 1 total transactions, got", len(pool.all))
+
+	pool.checkQueue()
+	if len(pool.pending) != 2 {
+		t.Error("expected 2 pending txs. Got", len(pool.pending))
 	}
 }
 
@@ -256,11 +237,8 @@ func TestMissingNonce(t *testing.T) {
 	if len(pool.pending) != 0 {
 		t.Error("expected 0 pending transactions, got", len(pool.pending))
 	}
-	if pool.queue[addr].Len() != 1 {
-		t.Error("expected 1 queued transaction, got", pool.queue[addr].Len())
-	}
-	if len(pool.all) != 1 {
-		t.Error("expected 1 total transactions, got", len(pool.all))
+	if len(pool.queue[addr]) != 1 {
+		t.Error("expected 1 queued transaction, got", len(pool.queue[addr]))
 	}
 }
 
@@ -292,11 +270,8 @@ func TestRemovedTxEvent(t *testing.T) {
 	currentState.AddBalance(from, big.NewInt(1000000000000))
 	pool.eventMux.Post(RemovedTransactionEvent{types.Transactions{tx}})
 	pool.eventMux.Post(ChainHeadEvent{nil})
-	if pool.pending[from].Len() != 1 {
-		t.Error("expected 1 pending tx, got", pool.pending[from].Len())
-	}
-	if len(pool.all) != 1 {
-		t.Error("expected 1 total transactions, got", len(pool.all))
+	if len(pool.pending) != 1 {
+		t.Error("expected 1 pending tx, got", len(pool.pending))
 	}
 }
 
@@ -317,50 +292,41 @@ func TestTransactionDropping(t *testing.T) {
 		tx10 = transaction(10, big.NewInt(100), key)
 		tx11 = transaction(11, big.NewInt(200), key)
 	)
-	pool.promoteTx(account, tx0.Hash(), tx0)
-	pool.promoteTx(account, tx1.Hash(), tx1)
-	pool.enqueueTx(tx10.Hash(), tx10)
-	pool.enqueueTx(tx11.Hash(), tx11)
+	pool.addTx(tx0.Hash(), account, tx0)
+	pool.addTx(tx1.Hash(), account, tx1)
+	pool.queueTx(tx10.Hash(), tx10)
+	pool.queueTx(tx11.Hash(), tx11)
 
 	// Check that pre and post validations leave the pool as is
-	if pool.pending[account].Len() != 2 {
-		t.Errorf("pending transaction mismatch: have %d, want %d", pool.pending[account].Len(), 2)
+	if len(pool.pending) != 2 {
+		t.Errorf("pending transaction mismatch: have %d, want %d", len(pool.pending), 2)
 	}
-	if pool.queue[account].Len() != 2 {
-		t.Errorf("queued transaction mismatch: have %d, want %d", pool.queue[account].Len(), 2)
-	}
-	if len(pool.all) != 4 {
-		t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), 4)
+	if len(pool.queue[account]) != 2 {
+		t.Errorf("queued transaction mismatch: have %d, want %d", len(pool.queue), 2)
 	}
 	pool.resetState()
-	if pool.pending[account].Len() != 2 {
-		t.Errorf("pending transaction mismatch: have %d, want %d", pool.pending[account].Len(), 2)
+	if len(pool.pending) != 2 {
+		t.Errorf("pending transaction mismatch: have %d, want %d", len(pool.pending), 2)
 	}
-	if pool.queue[account].Len() != 2 {
-		t.Errorf("queued transaction mismatch: have %d, want %d", pool.queue[account].Len(), 2)
-	}
-	if len(pool.all) != 4 {
-		t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), 4)
+	if len(pool.queue[account]) != 2 {
+		t.Errorf("queued transaction mismatch: have %d, want %d", len(pool.queue), 2)
 	}
 	// Reduce the balance of the account, and check that invalidated transactions are dropped
 	state.AddBalance(account, big.NewInt(-750))
 	pool.resetState()
 
-	if _, ok := pool.pending[account].txs.items[tx0.Nonce()]; !ok {
+	if _, ok := pool.pending[tx0.Hash()]; !ok {
 		t.Errorf("funded pending transaction missing: %v", tx0)
 	}
-	if _, ok := pool.pending[account].txs.items[tx1.Nonce()]; ok {
+	if _, ok := pool.pending[tx1.Hash()]; ok {
 		t.Errorf("out-of-fund pending transaction present: %v", tx1)
 	}
-	if _, ok := pool.queue[account].txs.items[tx10.Nonce()]; !ok {
+	if _, ok := pool.queue[account][tx10.Hash()]; !ok {
 		t.Errorf("funded queued transaction missing: %v", tx10)
 	}
-	if _, ok := pool.queue[account].txs.items[tx11.Nonce()]; ok {
+	if _, ok := pool.queue[account][tx11.Hash()]; ok {
 		t.Errorf("out-of-fund queued transaction present: %v", tx11)
 	}
-	if len(pool.all) != 2 {
-		t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), 2)
-	}
 }
 
 // Tests that if a transaction is dropped from the current pending pool (e.g. out
@@ -383,64 +349,55 @@ func TestTransactionPostponing(t *testing.T) {
 		} else {
 			tx = transaction(uint64(i), big.NewInt(500), key)
 		}
-		pool.promoteTx(account, tx.Hash(), tx)
+		pool.addTx(tx.Hash(), account, tx)
 		txns = append(txns, tx)
 	}
 	// Check that pre and post validations leave the pool as is
-	if pool.pending[account].Len() != len(txns) {
-		t.Errorf("pending transaction mismatch: have %d, want %d", pool.pending[account].Len(), len(txns))
+	if len(pool.pending) != len(txns) {
+		t.Errorf("pending transaction mismatch: have %d, want %d", len(pool.pending), len(txns))
 	}
-	if len(pool.queue) != 0 {
-		t.Errorf("queued transaction mismatch: have %d, want %d", pool.queue[account].Len(), 0)
-	}
-	if len(pool.all) != len(txns) {
-		t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), len(txns))
+	if len(pool.queue[account]) != 0 {
+		t.Errorf("queued transaction mismatch: have %d, want %d", len(pool.queue), 0)
 	}
 	pool.resetState()
-	if pool.pending[account].Len() != len(txns) {
-		t.Errorf("pending transaction mismatch: have %d, want %d", pool.pending[account].Len(), len(txns))
+	if len(pool.pending) != len(txns) {
+		t.Errorf("pending transaction mismatch: have %d, want %d", len(pool.pending), len(txns))
 	}
-	if len(pool.queue) != 0 {
-		t.Errorf("queued transaction mismatch: have %d, want %d", pool.queue[account].Len(), 0)
-	}
-	if len(pool.all) != len(txns) {
-		t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), len(txns))
+	if len(pool.queue[account]) != 0 {
+		t.Errorf("queued transaction mismatch: have %d, want %d", len(pool.queue), 0)
 	}
 	// Reduce the balance of the account, and check that transactions are reorganised
 	state.AddBalance(account, big.NewInt(-750))
 	pool.resetState()
 
-	if _, ok := pool.pending[account].txs.items[txns[0].Nonce()]; !ok {
+	if _, ok := pool.pending[txns[0].Hash()]; !ok {
 		t.Errorf("tx %d: valid and funded transaction missing from pending pool: %v", 0, txns[0])
 	}
-	if _, ok := pool.queue[account].txs.items[txns[0].Nonce()]; ok {
+	if _, ok := pool.queue[account][txns[0].Hash()]; ok {
 		t.Errorf("tx %d: valid and funded transaction present in future queue: %v", 0, txns[0])
 	}
 	for i, tx := range txns[1:] {
 		if i%2 == 1 {
-			if _, ok := pool.pending[account].txs.items[tx.Nonce()]; ok {
+			if _, ok := pool.pending[tx.Hash()]; ok {
 				t.Errorf("tx %d: valid but future transaction present in pending pool: %v", i+1, tx)
 			}
-			if _, ok := pool.queue[account].txs.items[tx.Nonce()]; !ok {
+			if _, ok := pool.queue[account][tx.Hash()]; !ok {
 				t.Errorf("tx %d: valid but future transaction missing from future queue: %v", i+1, tx)
 			}
 		} else {
-			if _, ok := pool.pending[account].txs.items[tx.Nonce()]; ok {
+			if _, ok := pool.pending[tx.Hash()]; ok {
 				t.Errorf("tx %d: out-of-fund transaction present in pending pool: %v", i+1, tx)
 			}
-			if _, ok := pool.queue[account].txs.items[tx.Nonce()]; ok {
+			if _, ok := pool.queue[account][tx.Hash()]; ok {
 				t.Errorf("tx %d: out-of-fund transaction present in future queue: %v", i+1, tx)
 			}
 		}
 	}
-	if len(pool.all) != len(txns)/2 {
-		t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), len(txns)/2)
-	}
 }
 
 // Tests that if the transaction count belonging to a single account goes above
 // some threshold, the higher transactions are dropped to prevent DOS attacks.
-func TestTransactionQueueAccountLimiting(t *testing.T) {
+func TestTransactionQueueLimiting(t *testing.T) {
 	// Create a test account and fund it
 	pool, key := setupTxPool()
 	account, _ := transaction(0, big.NewInt(0), key).From()
@@ -449,104 +406,23 @@ func TestTransactionQueueAccountLimiting(t *testing.T) {
 	state.AddBalance(account, big.NewInt(1000000))
 
 	// Keep queuing up transactions and make sure all above a limit are dropped
-	for i := uint64(1); i <= maxQueuedPerAccount+5; i++ {
+	for i := uint64(1); i <= maxQueued+5; i++ {
 		if err := pool.Add(transaction(i, big.NewInt(100000), key)); err != nil {
 			t.Fatalf("tx %d: failed to add transaction: %v", i, err)
 		}
 		if len(pool.pending) != 0 {
 			t.Errorf("tx %d: pending pool size mismatch: have %d, want %d", i, len(pool.pending), 0)
 		}
-		if i <= maxQueuedPerAccount {
-			if pool.queue[account].Len() != int(i) {
-				t.Errorf("tx %d: queue size mismatch: have %d, want %d", i, pool.queue[account].Len(), i)
+		if i <= maxQueued {
+			if len(pool.queue[account]) != int(i) {
+				t.Errorf("tx %d: queue size mismatch: have %d, want %d", i, len(pool.queue[account]), i)
 			}
 		} else {
-			if pool.queue[account].Len() != int(maxQueuedPerAccount) {
-				t.Errorf("tx %d: queue limit mismatch: have %d, want %d", i, pool.queue[account].Len(), maxQueuedPerAccount)
+			if len(pool.queue[account]) != maxQueued {
+				t.Errorf("tx %d: queue limit mismatch: have %d, want %d", i, len(pool.queue[account]), maxQueued)
 			}
 		}
 	}
-	if len(pool.all) != int(maxQueuedPerAccount) {
-		t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), maxQueuedPerAccount)
-	}
-}
-
-// Tests that if the transaction count belonging to multiple accounts go above
-// some threshold, the higher transactions are dropped to prevent DOS attacks.
-func TestTransactionQueueGlobalLimiting(t *testing.T) {
-	// Reduce the queue limits to shorten test time
-	defer func(old uint64) { maxQueuedInTotal = old }(maxQueuedInTotal)
-	maxQueuedInTotal = maxQueuedPerAccount * 3
-
-	// Create the pool to test the limit enforcement with
-	db, _ := ethdb.NewMemDatabase()
-	statedb, _ := state.New(common.Hash{}, db)
-
-	pool := NewTxPool(testChainConfig(), new(event.TypeMux), func() (*state.StateDB, error) { return statedb, nil }, func() *big.Int { return big.NewInt(1000000) })
-	pool.resetState()
-
-	// Create a number of test accounts and fund them
-	state, _ := pool.currentState()
-
-	keys := make([]*ecdsa.PrivateKey, 5)
-	for i := 0; i < len(keys); i++ {
-		keys[i], _ = crypto.GenerateKey()
-		state.AddBalance(crypto.PubkeyToAddress(keys[i].PublicKey), big.NewInt(1000000))
-	}
-	// Generate and queue a batch of transactions
-	nonces := make(map[common.Address]uint64)
-
-	txs := make(types.Transactions, 0, 3*maxQueuedInTotal)
-	for len(txs) < cap(txs) {
-		key := keys[rand.Intn(len(keys))]
-		addr := crypto.PubkeyToAddress(key.PublicKey)
-
-		txs = append(txs, transaction(nonces[addr]+1, big.NewInt(100000), key))
-		nonces[addr]++
-	}
-	// Import the batch and verify that limits have been enforced
-	pool.AddBatch(txs)
-
-	queued := 0
-	for addr, list := range pool.queue {
-		if list.Len() > int(maxQueuedPerAccount) {
-			t.Errorf("addr %x: queued accounts overflown allowance: %d > %d", addr, list.Len(), maxQueuedPerAccount)
-		}
-		queued += list.Len()
-	}
-	if queued > int(maxQueuedInTotal) {
-		t.Fatalf("total transactions overflow allowance: %d > %d", queued, maxQueuedInTotal)
-	}
-}
-
-// Tests that if an account remains idle for a prolonged amount of time, any
-// non-executable transactions queued up are dropped to prevent wasting resources
-// on shuffling them around.
-func TestTransactionQueueTimeLimiting(t *testing.T) {
-	// Reduce the queue limits to shorten test time
-	defer func(old time.Duration) { maxQueuedLifetime = old }(maxQueuedLifetime)
-	defer func(old time.Duration) { evictionInterval = old }(evictionInterval)
-	maxQueuedLifetime = time.Second
-	evictionInterval = time.Second
-
-	// Create a test account and fund it
-	pool, key := setupTxPool()
-	account, _ := transaction(0, big.NewInt(0), key).From()
-
-	state, _ := pool.currentState()
-	state.AddBalance(account, big.NewInt(1000000))
-
-	// Queue up a batch of transactions
-	for i := uint64(1); i <= maxQueuedPerAccount; i++ {
-		if err := pool.Add(transaction(i, big.NewInt(100000), key)); err != nil {
-			t.Fatalf("tx %d: failed to add transaction: %v", i, err)
-		}
-	}
-	// Wait until at least two expiration cycles hit and make sure the transactions are gone
-	time.Sleep(2 * evictionInterval)
-	if len(pool.queue) > 0 {
-		t.Fatalf("old transactions remained after eviction")
-	}
 }
 
 // Tests that even if the transaction count belonging to a single account goes
@@ -561,20 +437,17 @@ func TestTransactionPendingLimiting(t *testing.T) {
 	state.AddBalance(account, big.NewInt(1000000))
 
 	// Keep queuing up transactions and make sure all above a limit are dropped
-	for i := uint64(0); i < maxQueuedPerAccount+5; i++ {
+	for i := uint64(0); i < maxQueued+5; i++ {
 		if err := pool.Add(transaction(i, big.NewInt(100000), key)); err != nil {
 			t.Fatalf("tx %d: failed to add transaction: %v", i, err)
 		}
-		if pool.pending[account].Len() != int(i)+1 {
-			t.Errorf("tx %d: pending pool size mismatch: have %d, want %d", i, pool.pending[account].Len(), i+1)
+		if len(pool.pending) != int(i)+1 {
+			t.Errorf("tx %d: pending pool size mismatch: have %d, want %d", i, len(pool.pending), i+1)
 		}
-		if len(pool.queue) != 0 {
-			t.Errorf("tx %d: queue size mismatch: have %d, want %d", i, pool.queue[account].Len(), 0)
+		if len(pool.queue[account]) != 0 {
+			t.Errorf("tx %d: queue size mismatch: have %d, want %d", i, len(pool.queue[account]), 0)
 		}
 	}
-	if len(pool.all) != int(maxQueuedPerAccount+5) {
-		t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), maxQueuedPerAccount+5)
-	}
 }
 
 // Tests that the transaction limits are enforced the same way irrelevant whether
@@ -589,132 +462,39 @@ func testTransactionLimitingEquivalency(t *testing.T, origin uint64) {
 	state1, _ := pool1.currentState()
 	state1.AddBalance(account1, big.NewInt(1000000))
 
-	for i := uint64(0); i < maxQueuedPerAccount+5; i++ {
+	for i := uint64(0); i < maxQueued+5; i++ {
 		if err := pool1.Add(transaction(origin+i, big.NewInt(100000), key1)); err != nil {
 			t.Fatalf("tx %d: failed to add transaction: %v", i, err)
 		}
 	}
-	// Add a batch of transactions to a pool in one big batch
+	// Add a batch of transactions to a pool in one bit batch
 	pool2, key2 := setupTxPool()
 	account2, _ := transaction(0, big.NewInt(0), key2).From()
 	state2, _ := pool2.currentState()
 	state2.AddBalance(account2, big.NewInt(1000000))
 
 	txns := []*types.Transaction{}
-	for i := uint64(0); i < maxQueuedPerAccount+5; i++ {
+	for i := uint64(0); i < maxQueued+5; i++ {
 		txns = append(txns, transaction(origin+i, big.NewInt(100000), key2))
 	}
-	pool2.AddBatch(txns)
+	pool2.AddTransactions(txns)
 
 	// Ensure the batch optimization honors the same pool mechanics
 	if len(pool1.pending) != len(pool2.pending) {
 		t.Errorf("pending transaction count mismatch: one-by-one algo: %d, batch algo: %d", len(pool1.pending), len(pool2.pending))
 	}
-	if len(pool1.queue) != len(pool2.queue) {
-		t.Errorf("queued transaction count mismatch: one-by-one algo: %d, batch algo: %d", len(pool1.queue), len(pool2.queue))
-	}
-	if len(pool1.all) != len(pool2.all) {
-		t.Errorf("total transaction count mismatch: one-by-one algo %d, batch algo %d", len(pool1.all), len(pool2.all))
-	}
-}
-
-// Tests that if the transaction count belonging to multiple accounts go above
-// some hard threshold, the higher transactions are dropped to prevent DOS
-// attacks.
-func TestTransactionPendingGlobalLimiting(t *testing.T) {
-	// Reduce the queue limits to shorten test time
-	defer func(old uint64) { maxPendingTotal = old }(maxPendingTotal)
-	maxPendingTotal = minPendingPerAccount * 10
-
-	// Create the pool to test the limit enforcement with
-	db, _ := ethdb.NewMemDatabase()
-	statedb, _ := state.New(common.Hash{}, db)
-
-	pool := NewTxPool(testChainConfig(), new(event.TypeMux), func() (*state.StateDB, error) { return statedb, nil }, func() *big.Int { return big.NewInt(1000000) })
-	pool.resetState()
-
-	// Create a number of test accounts and fund them
-	state, _ := pool.currentState()
-
-	keys := make([]*ecdsa.PrivateKey, 5)
-	for i := 0; i < len(keys); i++ {
-		keys[i], _ = crypto.GenerateKey()
-		state.AddBalance(crypto.PubkeyToAddress(keys[i].PublicKey), big.NewInt(1000000))
-	}
-	// Generate and queue a batch of transactions
-	nonces := make(map[common.Address]uint64)
-
-	txs := types.Transactions{}
-	for _, key := range keys {
-		addr := crypto.PubkeyToAddress(key.PublicKey)
-		for j := 0; j < int(maxPendingTotal)/len(keys)*2; j++ {
-			txs = append(txs, transaction(nonces[addr], big.NewInt(100000), key))
-			nonces[addr]++
-		}
-	}
-	// Import the batch and verify that limits have been enforced
-	pool.AddBatch(txs)
-
-	pending := 0
-	for _, list := range pool.pending {
-		pending += list.Len()
-	}
-	if pending > int(maxPendingTotal) {
-		t.Fatalf("total pending transactions overflow allowance: %d > %d", pending, maxPendingTotal)
-	}
-}
-
-// Tests that if the transaction count belonging to multiple accounts go above
-// some hard threshold, if they are under the minimum guaranteed slot count then
-// the transactions are still kept.
-func TestTransactionPendingMinimumAllowance(t *testing.T) {
-	// Reduce the queue limits to shorten test time
-	defer func(old uint64) { maxPendingTotal = old }(maxPendingTotal)
-	maxPendingTotal = 0
-
-	// Create the pool to test the limit enforcement with
-	db, _ := ethdb.NewMemDatabase()
-	statedb, _ := state.New(common.Hash{}, db)
-
-	pool := NewTxPool(testChainConfig(), new(event.TypeMux), func() (*state.StateDB, error) { return statedb, nil }, func() *big.Int { return big.NewInt(1000000) })
-	pool.resetState()
-
-	// Create a number of test accounts and fund them
-	state, _ := pool.currentState()
-
-	keys := make([]*ecdsa.PrivateKey, 5)
-	for i := 0; i < len(keys); i++ {
-		keys[i], _ = crypto.GenerateKey()
-		state.AddBalance(crypto.PubkeyToAddress(keys[i].PublicKey), big.NewInt(1000000))
-	}
-	// Generate and queue a batch of transactions
-	nonces := make(map[common.Address]uint64)
-
-	txs := types.Transactions{}
-	for _, key := range keys {
-		addr := crypto.PubkeyToAddress(key.PublicKey)
-		for j := 0; j < int(minPendingPerAccount)*2; j++ {
-			txs = append(txs, transaction(nonces[addr], big.NewInt(100000), key))
-			nonces[addr]++
-		}
-	}
-	// Import the batch and verify that limits have been enforced
-	pool.AddBatch(txs)
-
-	for addr, list := range pool.pending {
-		if list.Len() != int(minPendingPerAccount) {
-			t.Errorf("addr %x: total pending transactions mismatch: have %d, want %d", addr, list.Len(), minPendingPerAccount)
-		}
+	if len(pool1.queue[account1]) != len(pool2.queue[account2]) {
+		t.Errorf("queued transaction count mismatch: one-by-one algo: %d, batch algo: %d", len(pool1.queue[account1]), len(pool2.queue[account2]))
 	}
 }
 
 // Benchmarks the speed of validating the contents of the pending queue of the
 // transaction pool.
-func BenchmarkPendingDemotion100(b *testing.B)   { benchmarkPendingDemotion(b, 100) }
-func BenchmarkPendingDemotion1000(b *testing.B)  { benchmarkPendingDemotion(b, 1000) }
-func BenchmarkPendingDemotion10000(b *testing.B) { benchmarkPendingDemotion(b, 10000) }
+func BenchmarkValidatePool100(b *testing.B)   { benchmarkValidatePool(b, 100) }
+func BenchmarkValidatePool1000(b *testing.B)  { benchmarkValidatePool(b, 1000) }
+func BenchmarkValidatePool10000(b *testing.B) { benchmarkValidatePool(b, 10000) }
 
-func benchmarkPendingDemotion(b *testing.B, size int) {
+func benchmarkValidatePool(b *testing.B, size int) {
 	// Add a batch of transactions to a pool one by one
 	pool, key := setupTxPool()
 	account, _ := transaction(0, big.NewInt(0), key).From()
@@ -723,22 +503,22 @@ func benchmarkPendingDemotion(b *testing.B, size int) {
 
 	for i := 0; i < size; i++ {
 		tx := transaction(uint64(i), big.NewInt(100000), key)
-		pool.promoteTx(account, tx.Hash(), tx)
+		pool.addTx(tx.Hash(), account, tx)
 	}
 	// Benchmark the speed of pool validation
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		pool.demoteUnexecutables()
+		pool.validatePool()
 	}
 }
 
 // Benchmarks the speed of scheduling the contents of the future queue of the
 // transaction pool.
-func BenchmarkFuturePromotion100(b *testing.B)   { benchmarkFuturePromotion(b, 100) }
-func BenchmarkFuturePromotion1000(b *testing.B)  { benchmarkFuturePromotion(b, 1000) }
-func BenchmarkFuturePromotion10000(b *testing.B) { benchmarkFuturePromotion(b, 10000) }
+func BenchmarkCheckQueue100(b *testing.B)   { benchmarkCheckQueue(b, 100) }
+func BenchmarkCheckQueue1000(b *testing.B)  { benchmarkCheckQueue(b, 1000) }
+func BenchmarkCheckQueue10000(b *testing.B) { benchmarkCheckQueue(b, 10000) }
 
-func benchmarkFuturePromotion(b *testing.B, size int) {
+func benchmarkCheckQueue(b *testing.B, size int) {
 	// Add a batch of transactions to a pool one by one
 	pool, key := setupTxPool()
 	account, _ := transaction(0, big.NewInt(0), key).From()
@@ -747,56 +527,11 @@ func benchmarkFuturePromotion(b *testing.B, size int) {
 
 	for i := 0; i < size; i++ {
 		tx := transaction(uint64(1+i), big.NewInt(100000), key)
-		pool.enqueueTx(tx.Hash(), tx)
+		pool.queueTx(tx.Hash(), tx)
 	}
 	// Benchmark the speed of pool validation
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		pool.promoteExecutables()
-	}
-}
-
-// Benchmarks the speed of iterative transaction insertion.
-func BenchmarkPoolInsert(b *testing.B) {
-	// Generate a batch of transactions to enqueue into the pool
-	pool, key := setupTxPool()
-	account, _ := transaction(0, big.NewInt(0), key).From()
-	state, _ := pool.currentState()
-	state.AddBalance(account, big.NewInt(1000000))
-
-	txs := make(types.Transactions, b.N)
-	for i := 0; i < b.N; i++ {
-		txs[i] = transaction(uint64(i), big.NewInt(100000), key)
-	}
-	// Benchmark importing the transactions into the queue
-	b.ResetTimer()
-	for _, tx := range txs {
-		pool.Add(tx)
-	}
-}
-
-// Benchmarks the speed of batched transaction insertion.
-func BenchmarkPoolBatchInsert100(b *testing.B)   { benchmarkPoolBatchInsert(b, 100) }
-func BenchmarkPoolBatchInsert1000(b *testing.B)  { benchmarkPoolBatchInsert(b, 1000) }
-func BenchmarkPoolBatchInsert10000(b *testing.B) { benchmarkPoolBatchInsert(b, 10000) }
-
-func benchmarkPoolBatchInsert(b *testing.B, size int) {
-	// Generate a batch of transactions to enqueue into the pool
-	pool, key := setupTxPool()
-	account, _ := transaction(0, big.NewInt(0), key).From()
-	state, _ := pool.currentState()
-	state.AddBalance(account, big.NewInt(1000000))
-
-	batches := make([]types.Transactions, b.N)
-	for i := 0; i < b.N; i++ {
-		batches[i] = make(types.Transactions, size)
-		for j := 0; j < size; j++ {
-			batches[i][j] = transaction(uint64(size*i+j), big.NewInt(100000), key)
-		}
-	}
-	// Benchmark importing the transactions into the queue
-	b.ResetTimer()
-	for _, batch := range batches {
-		pool.AddBatch(batch)
+		pool.checkQueue()
 	}
 }

core/types/transaction.go

@@ -23,18 +23,19 @@ import (
 	"fmt"
 	"io"
 	"math/big"
+	"sort"
 	"sync/atomic"
 
 	"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"
 	"github.com/ethereum/go-ethereum/rlp"
 )
 
 var ErrInvalidSig = errors.New("invalid v, r, s values")
 
 type Transaction struct {
-	signer Signer
-
 	data txdata
 	// caches
 	hash atomic.Value
@@ -48,27 +49,24 @@ type txdata struct {
 	Recipient       *common.Address `rlp:"nil"` // nil means contract creation
 	Amount          *big.Int
 	Payload         []byte
-	V, R, S         *big.Int // signature
+	V               byte     // signature
+	R, S            *big.Int // signature
 }
 
 func NewContractCreation(nonce uint64, amount, gasLimit, gasPrice *big.Int, data []byte) *Transaction {
 	if len(data) > 0 {
 		data = common.CopyBytes(data)
 	}
-	return &Transaction{
-		signer: HomesteadSigner{},
-		data: txdata{
-			AccountNonce: nonce,
-			Recipient:    nil,
-			Amount:       new(big.Int).Set(amount),
-			GasLimit:     new(big.Int).Set(gasLimit),
-			Price:        new(big.Int).Set(gasPrice),
-			Payload:      data,
-			V:            new(big.Int),
-			R:            new(big.Int),
-			S:            new(big.Int),
-		},
-	}
+	return &Transaction{data: txdata{
+		AccountNonce: nonce,
+		Recipient:    nil,
+		Amount:       new(big.Int).Set(amount),
+		GasLimit:     new(big.Int).Set(gasLimit),
+		Price:        new(big.Int).Set(gasPrice),
+		Payload:      data,
+		R:            new(big.Int),
+		S:            new(big.Int),
+	}}
 }
 
 func NewTransaction(nonce uint64, to common.Address, amount, gasLimit, gasPrice *big.Int, data []byte) *Transaction {
@@ -82,7 +80,6 @@ func NewTransaction(nonce uint64, to common.Address, amount, gasLimit, gasPrice
 		Amount:       new(big.Int),
 		GasLimit:     new(big.Int),
 		Price:        new(big.Int),
-		V:            new(big.Int),
 		R:            new(big.Int),
 		S:            new(big.Int),
 	}
@@ -95,24 +92,7 @@ func NewTransaction(nonce uint64, to common.Address, amount, gasLimit, gasPrice
 	if gasPrice != nil {
 		d.Price.Set(gasPrice)
 	}
-	return &Transaction{signer: HomesteadSigner{}, data: d}
-}
-
-func (tx *Transaction) SetSigner(s Signer) {
-	// reset the cached value incase another value was cached
-	tx.from.Store((*common.Address)(nil))
-
-	tx.signer = s
-}
-
-// ChainId returns which chain id this transaction was signed for (if at all)
-func (tx *Transaction) ChainId() *big.Int {
-	return deriveChainId(tx.data.V)
-}
-
-// Protected returns whether the transaction is pretected from replay protection
-func (tx *Transaction) Protected() bool {
-	return isProtectedV(tx.data.V)
+	return &Transaction{data: d}
 }
 
 func (tx *Transaction) EncodeRLP(w io.Writer) error {
@@ -125,7 +105,6 @@ func (tx *Transaction) DecodeRLP(s *rlp.Stream) error {
 	if err == nil {
 		tx.size.Store(common.StorageSize(rlp.ListSize(size)))
 	}
-	tx.signer = HomesteadSigner{}
 	return err
 }
 
@@ -158,7 +137,14 @@ func (tx *Transaction) Hash() common.Hash {
 // SigHash returns the hash to be signed by the sender.
 // It does not uniquely identify the transaction.
 func (tx *Transaction) SigHash() common.Hash {
-	return tx.signer.Hash(tx)
+	return rlpHash([]interface{}{
+		tx.data.AccountNonce,
+		tx.data.Price,
+		tx.data.GasLimit,
+		tx.data.Recipient,
+		tx.data.Amount,
+		tx.data.Payload,
+	})
 }
 
 func (tx *Transaction) Size() common.StorageSize {
@@ -209,17 +195,15 @@ func (tx *Transaction) FromFrontier() (common.Address, error) {
 
 func doFrom(tx *Transaction, homestead bool) (common.Address, error) {
 	if from := tx.from.Load(); from != nil {
-		if faddr := from.(*common.Address); faddr != nil {
-			return *faddr, nil
-		}
+		return from.(common.Address), nil
 	}
-	pubkey, err := tx.signer.PublicKey(tx)
+	pubkey, err := tx.publicKey(homestead)
 	if err != nil {
 		return common.Address{}, err
 	}
 	var addr common.Address
 	copy(addr[:], crypto.Keccak256(pubkey[1:])[12:])
-	tx.from.Store(&addr)
+	tx.from.Store(addr)
 	return addr, nil
 }
 
@@ -231,20 +215,52 @@ func (tx *Transaction) Cost() *big.Int {
 }
 
 func (tx *Transaction) SignatureValues() (v byte, r *big.Int, s *big.Int) {
-	return SignatureValues(tx.signer, tx)
+	return tx.data.V, new(big.Int).Set(tx.data.R), new(big.Int).Set(tx.data.S)
 }
 
-func (tx *Transaction) RawSignatureValues() (v *big.Int, r *big.Int, s *big.Int) {
-	return tx.data.V, tx.data.R, tx.data.S
+func (tx *Transaction) publicKey(homestead bool) ([]byte, error) {
+	if !crypto.ValidateSignatureValues(tx.data.V, tx.data.R, tx.data.S, homestead) {
+		return nil, ErrInvalidSig
+	}
+
+	// encode the signature in uncompressed format
+	r, s := tx.data.R.Bytes(), tx.data.S.Bytes()
+	sig := make([]byte, 65)
+	copy(sig[32-len(r):32], r)
+	copy(sig[64-len(s):64], s)
+	sig[64] = tx.data.V - 27
+
+	// recover the public key from the signature
+	hash := tx.SigHash()
+	pub, err := crypto.Ecrecover(hash[:], sig)
+	if err != nil {
+		glog.V(logger.Error).Infof("Could not get pubkey from signature: ", err)
+		return nil, err
+	}
+	if len(pub) == 0 || pub[0] != 4 {
+		return nil, errors.New("invalid public key")
+	}
+	return pub, nil
 }
 
 func (tx *Transaction) WithSignature(sig []byte) (*Transaction, error) {
-	return tx.signer.WithSignature(tx, sig)
+	if len(sig) != 65 {
+		panic(fmt.Sprintf("wrong size for signature: got %d, want 65", len(sig)))
+	}
+	cpy := &Transaction{data: tx.data}
+	cpy.data.R = new(big.Int).SetBytes(sig[:32])
+	cpy.data.S = new(big.Int).SetBytes(sig[32:64])
+	cpy.data.V = sig[64] + 27
+	return cpy, nil
 }
 
 func (tx *Transaction) SignECDSA(prv *ecdsa.PrivateKey) (*Transaction, error) {
-	tx, err := tx.signer.SignECDSA(tx, prv)
-	return tx, err
+	h := tx.SigHash()
+	sig, err := crypto.Sign(h[:], prv)
+	if err != nil {
+		return nil, err
+	}
+	return tx.WithSignature(sig)
 }
 
 func (tx *Transaction) String() string {
@@ -353,58 +369,49 @@ func (s *TxByPrice) Pop() interface{} {
 	return x
 }
 
-// TransactionsByPriceAndNonce represents a set of transactions that can return
-// transactions in a profit-maximising sorted order, while supporting removing
-// entire batches of transactions for non-executable accounts.
-type TransactionsByPriceAndNonce struct {
-	txs   map[common.Address]Transactions // Per account nonce-sorted list of transactions
-	heads TxByPrice                       // Next transaction for each unique account (price heap)
-}
-
-// NewTransactionsByPriceAndNonce creates a transaction set that can retrieve
-// price sorted transactions in a nonce-honouring way.
+// SortByPriceAndNonce sorts the transactions by price in such a way that the
+// nonce orderings within a single account are maintained.
 //
-// Note, the input map is reowned so the caller should not interact any more with
-// if after providng it to the constructor.
-func NewTransactionsByPriceAndNonce(txs map[common.Address]Transactions) *TransactionsByPriceAndNonce {
+// Note, this is not as trivial as it seems from the first look as there are three
+// different criteria that need to be taken into account (price, nonce, account
+// match), which cannot be done with any plain sorting method, as certain items
+// cannot be compared without context.
+//
+// This method first sorts the separates the list of transactions into individual
+// sender accounts and sorts them by nonce. After the account nonce ordering is
+// satisfied, the results are merged back together by price, always comparing only
+// the head transaction from each account. This is done via a heap to keep it fast.
+func SortByPriceAndNonce(txs []*Transaction) {
+	// Separate the transactions by account and sort by nonce
+	byNonce := make(map[common.Address][]*Transaction)
+	for _, tx := range txs {
+		acc, _ := tx.From() // we only sort valid txs so this cannot fail
+		byNonce[acc] = append(byNonce[acc], tx)
+	}
+	for _, accTxs := range byNonce {
+		sort.Sort(TxByNonce(accTxs))
+	}
 	// Initialize a price based heap with the head transactions
-	heads := make(TxByPrice, 0, len(txs))
-	for acc, accTxs := range txs {
-		heads = append(heads, accTxs[0])
-		txs[acc] = accTxs[1:]
+	byPrice := make(TxByPrice, 0, len(byNonce))
+	for acc, accTxs := range byNonce {
+		byPrice = append(byPrice, accTxs[0])
+		byNonce[acc] = accTxs[1:]
 	}
-	heap.Init(&heads)
+	heap.Init(&byPrice)
 
-	// Assemble and return the transaction set
-	return &TransactionsByPriceAndNonce{
-		txs:   txs,
-		heads: heads,
+	// Merge by replacing the best with the next from the same account
+	txs = txs[:0]
+	for len(byPrice) > 0 {
+		// Retrieve the next best transaction by price
+		best := heap.Pop(&byPrice).(*Transaction)
+
+		// Push in its place the next transaction from the same account
+		acc, _ := best.From() // we only sort valid txs so this cannot fail
+		if accTxs, ok := byNonce[acc]; ok && len(accTxs) > 0 {
+			heap.Push(&byPrice, accTxs[0])
+			byNonce[acc] = accTxs[1:]
+		}
+		// Accumulate the best priced transaction
+		txs = append(txs, best)
 	}
 }
-
-// Peek returns the next transaction by price.
-func (t *TransactionsByPriceAndNonce) Peek() *Transaction {
-	if len(t.heads) == 0 {
-		return nil
-	}
-	return t.heads[0]
-}
-
-// Shift replaces the current best head with the next one from the same account.
-func (t *TransactionsByPriceAndNonce) Shift() {
-	acc, _ := t.heads[0].From() // we only sort valid txs so this cannot fail
-
-	if txs, ok := t.txs[acc]; ok && len(txs) > 0 {
-		t.heads[0], t.txs[acc] = txs[0], txs[1:]
-		heap.Fix(&t.heads, 0)
-	} else {
-		heap.Pop(&t.heads)
-	}
-}
-
-// Pop removes the best transaction, *not* replacing it with the next one from
-// the same account. This should be used when a transaction cannot be executed
-// and hence all subsequent ones should be discarded from the same account.
-func (t *TransactionsByPriceAndNonce) Pop() {
-	heap.Pop(&t.heads)
-}

core/types/transaction_signing.go

@@ -1,376 +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 types
-
-import (
-	"crypto/ecdsa"
-	"errors"
-	"fmt"
-	"math/big"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/params"
-)
-
-var ErrInvalidChainId = errors.New("invalid chain id for signer")
-
-// deriveSigner makes a *best* guess about which signer to use.
-func deriveSigner(V *big.Int) Signer {
-	if V.BitLen() > 0 && isProtectedV(V) {
-		return EIP155Signer{chainId: deriveChainId(V)}
-	} else {
-		return HomesteadSigner{}
-	}
-}
-
-func pickSigner(rules params.Rules) Signer {
-	var signer Signer
-	switch {
-	case rules.IsEIP155:
-		signer = NewEIP155Signer(rules.ChainId)
-	case rules.IsHomestead:
-		signer = HomesteadSigner{}
-	default:
-		signer = FrontierSigner{}
-	}
-	return signer
-}
-
-func isProtectedV(V *big.Int) bool {
-	if V.BitLen() <= 8 {
-		v := V.Uint64()
-		return v != 27 && v != 28
-	}
-	// anything not 27 or 28 are considered unprotected
-	return true
-}
-
-// MakeSigner returns a Signer based on the given chain config and block number.
-func MakeSigner(config *params.ChainConfig, blockNumber *big.Int) Signer {
-	var signer Signer
-	switch {
-	case config.IsEIP155(blockNumber):
-		signer = NewEIP155Signer(config.ChainId)
-	case config.IsHomestead(blockNumber):
-		signer = HomesteadSigner{}
-	default:
-		signer = FrontierSigner{}
-	}
-	return signer
-}
-
-// SignECDSA signs the transaction using the given signer and private key
-func SignECDSA(s Signer, tx *Transaction, prv *ecdsa.PrivateKey) (*Transaction, error) {
-	h := s.Hash(tx)
-	sig, err := crypto.Sign(h[:], prv)
-	if err != nil {
-		return nil, err
-	}
-	return s.WithSignature(tx, sig)
-}
-
-// From derives the sender from the tx using the signer derivation
-// functions.
-
-// From returns the address derived from the signature (V, R, S) using secp256k1
-// elliptic curve and an error if it failed deriving or upon an incorrect
-// signature.
-//
-// From may cache the address, allowing it to be used regardless of
-// signing method.
-func From(signer Signer, tx *Transaction, cache bool) (common.Address, error) {
-	if from := tx.from.Load(); from != nil {
-		return from.(common.Address), nil
-	}
-
-	pubkey, err := signer.PublicKey(tx)
-	if err != nil {
-		return common.Address{}, err
-	}
-	var addr common.Address
-	copy(addr[:], crypto.Keccak256(pubkey[1:])[12:])
-	if cache {
-		tx.from.Store(addr)
-	}
-	return addr, nil
-}
-
-// SignatureValues returns the ECDSA signature values contained in the transaction.
-func SignatureValues(signer Signer, tx *Transaction) (v byte, r *big.Int, s *big.Int) {
-	return normaliseV(signer, tx.data.V), new(big.Int).Set(tx.data.R), new(big.Int).Set(tx.data.S)
-}
-
-type Signer interface {
-	// Hash returns the rlp encoded hash for signatures
-	Hash(tx *Transaction) common.Hash
-	// PubilcKey returns the public key derived from the signature
-	PublicKey(tx *Transaction) ([]byte, error)
-	// SignECDSA signs the transaction with the given and returns a copy of the tx
-	SignECDSA(tx *Transaction, prv *ecdsa.PrivateKey) (*Transaction, error)
-	// WithSignature returns a copy of the transaction with the given signature
-	WithSignature(tx *Transaction, sig []byte) (*Transaction, error)
-}
-
-// EIP155Transaction implements TransactionInterface using the
-// EIP155 rules
-type EIP155Signer struct {
-	HomesteadSigner
-
-	chainId, chainIdMul *big.Int
-}
-
-func NewEIP155Signer(chainId *big.Int) EIP155Signer {
-	return EIP155Signer{
-		chainId:    chainId,
-		chainIdMul: new(big.Int).Mul(chainId, big.NewInt(2)),
-	}
-}
-
-func (s EIP155Signer) SignECDSA(tx *Transaction, prv *ecdsa.PrivateKey) (*Transaction, error) {
-	return SignECDSA(s, tx, prv)
-}
-
-func (s EIP155Signer) PublicKey(tx *Transaction) ([]byte, error) {
-	// if the transaction is not protected fall back to homestead signer
-	if !tx.Protected() {
-		return (HomesteadSigner{}).PublicKey(tx)
-	}
-	if tx.ChainId().Cmp(s.chainId) != 0 {
-		return nil, ErrInvalidChainId
-	}
-
-	V := normaliseV(s, tx.data.V)
-	if !crypto.ValidateSignatureValues(V, tx.data.R, tx.data.S, true) {
-		return nil, ErrInvalidSig
-	}
-
-	// encode the signature in uncompressed format
-	R, S := tx.data.R.Bytes(), tx.data.S.Bytes()
-	sig := make([]byte, 65)
-	copy(sig[32-len(R):32], R)
-	copy(sig[64-len(S):64], S)
-	sig[64] = V - 27
-
-	// recover the public key from the signature
-	hash := s.Hash(tx)
-	pub, err := crypto.Ecrecover(hash[:], sig)
-	if err != nil {
-		return nil, err
-	}
-	if len(pub) == 0 || pub[0] != 4 {
-		return nil, errors.New("invalid public key")
-	}
-	return pub, nil
-}
-
-// WithSignature returns a new transaction with the given signature.
-// This signature needs to be formatted as described in the yellow paper (v+27).
-func (s EIP155Signer) WithSignature(tx *Transaction, sig []byte) (*Transaction, error) {
-	if len(sig) != 65 {
-		panic(fmt.Sprintf("wrong size for snature: got %d, want 65", len(sig)))
-	}
-
-	cpy := &Transaction{signer: tx.signer, data: tx.data}
-	cpy.data.R = new(big.Int).SetBytes(sig[:32])
-	cpy.data.S = new(big.Int).SetBytes(sig[32:64])
-	cpy.data.V = new(big.Int).SetBytes([]byte{sig[64]})
-	if s.chainId.BitLen() > 0 {
-		cpy.data.V = big.NewInt(int64(sig[64] + 35))
-		cpy.data.V.Add(cpy.data.V, s.chainIdMul)
-	}
-	return cpy, nil
-}
-
-// Hash returns the hash to be signed by the sender.
-// It does not uniquely identify the transaction.
-func (s EIP155Signer) Hash(tx *Transaction) common.Hash {
-	return rlpHash([]interface{}{
-		tx.data.AccountNonce,
-		tx.data.Price,
-		tx.data.GasLimit,
-		tx.data.Recipient,
-		tx.data.Amount,
-		tx.data.Payload,
-		s.chainId, uint(0), uint(0),
-	})
-}
-
-func (s EIP155Signer) SigECDSA(tx *Transaction, prv *ecdsa.PrivateKey) (*Transaction, error) {
-	h := s.Hash(tx)
-	sig, err := crypto.Sign(h[:], prv)
-	if err != nil {
-		return nil, err
-	}
-	return s.WithSignature(tx, sig)
-}
-
-// HomesteadTransaction implements TransactionInterface using the
-// homestead rules.
-type HomesteadSigner struct{}
-
-// WithSignature returns a new transaction with the given snature.
-// This snature needs to be formatted as described in the yellow paper (v+27).
-func (hs HomesteadSigner) WithSignature(tx *Transaction, sig []byte) (*Transaction, error) {
-	if len(sig) != 65 {
-		panic(fmt.Sprintf("wrong size for snature: got %d, want 65", len(sig)))
-	}
-	cpy := &Transaction{signer: tx.signer, data: tx.data}
-	cpy.data.R = new(big.Int).SetBytes(sig[:32])
-	cpy.data.S = new(big.Int).SetBytes(sig[32:64])
-	cpy.data.V = new(big.Int).SetBytes([]byte{sig[64] + 27})
-	return cpy, nil
-}
-
-func (hs HomesteadSigner) SignECDSA(tx *Transaction, prv *ecdsa.PrivateKey) (*Transaction, error) {
-	h := hs.Hash(tx)
-	sig, err := crypto.Sign(h[:], prv)
-	if err != nil {
-		return nil, err
-	}
-	return hs.WithSignature(tx, sig)
-}
-
-func (hs HomesteadSigner) PublicKey(tx *Transaction) ([]byte, error) {
-	if tx.data.V.BitLen() > 8 {
-		return nil, ErrInvalidSig
-	}
-	V := byte(tx.data.V.Uint64())
-	if !crypto.ValidateSignatureValues(V, tx.data.R, tx.data.S, true) {
-		return nil, ErrInvalidSig
-	}
-	// encode the snature in uncompressed format
-	r, s := tx.data.R.Bytes(), tx.data.S.Bytes()
-	sig := make([]byte, 65)
-	copy(sig[32-len(r):32], r)
-	copy(sig[64-len(s):64], s)
-	sig[64] = V - 27
-
-	// recover the public key from the snature
-	hash := hs.Hash(tx)
-	pub, err := crypto.Ecrecover(hash[:], sig)
-	if err != nil {
-		return nil, err
-	}
-	if len(pub) == 0 || pub[0] != 4 {
-		return nil, errors.New("invalid public key")
-	}
-	return pub, nil
-}
-
-// Hash returns the hash to be sned by the sender.
-// It does not uniquely identify the transaction.
-func (hs HomesteadSigner) Hash(tx *Transaction) common.Hash {
-	return rlpHash([]interface{}{
-		tx.data.AccountNonce,
-		tx.data.Price,
-		tx.data.GasLimit,
-		tx.data.Recipient,
-		tx.data.Amount,
-		tx.data.Payload,
-	})
-}
-
-type FrontierSigner struct{}
-
-// WithSignature returns a new transaction with the given snature.
-// This snature needs to be formatted as described in the yellow paper (v+27).
-func (fs FrontierSigner) WithSignature(tx *Transaction, sig []byte) (*Transaction, error) {
-	if len(sig) != 65 {
-		panic(fmt.Sprintf("wrong size for snature: got %d, want 65", len(sig)))
-	}
-	cpy := &Transaction{signer: tx.signer, data: tx.data}
-	cpy.data.R = new(big.Int).SetBytes(sig[:32])
-	cpy.data.S = new(big.Int).SetBytes(sig[32:64])
-	cpy.data.V = new(big.Int).SetBytes([]byte{sig[64] + 27})
-	return cpy, nil
-}
-
-func (fs FrontierSigner) SignECDSA(tx *Transaction, prv *ecdsa.PrivateKey) (*Transaction, error) {
-	h := fs.Hash(tx)
-	sig, err := crypto.Sign(h[:], prv)
-	if err != nil {
-		return nil, err
-	}
-	return fs.WithSignature(tx, sig)
-}
-
-// Hash returns the hash to be sned by the sender.
-// It does not uniquely identify the transaction.
-func (fs FrontierSigner) Hash(tx *Transaction) common.Hash {
-	return rlpHash([]interface{}{
-		tx.data.AccountNonce,
-		tx.data.Price,
-		tx.data.GasLimit,
-		tx.data.Recipient,
-		tx.data.Amount,
-		tx.data.Payload,
-	})
-}
-
-func (fs FrontierSigner) PublicKey(tx *Transaction) ([]byte, error) {
-	if tx.data.V.BitLen() > 8 {
-		return nil, ErrInvalidSig
-	}
-
-	V := byte(tx.data.V.Uint64())
-	if !crypto.ValidateSignatureValues(V, tx.data.R, tx.data.S, false) {
-		return nil, ErrInvalidSig
-	}
-	// encode the snature in uncompressed format
-	r, s := tx.data.R.Bytes(), tx.data.S.Bytes()
-	sig := make([]byte, 65)
-	copy(sig[32-len(r):32], r)
-	copy(sig[64-len(s):64], s)
-	sig[64] = V - 27
-
-	// recover the public key from the snature
-	hash := fs.Hash(tx)
-	pub, err := crypto.Ecrecover(hash[:], sig)
-	if err != nil {
-		return nil, err
-	}
-	if len(pub) == 0 || pub[0] != 4 {
-		return nil, errors.New("invalid public key")
-	}
-	return pub, nil
-}
-
-// normaliseV returns the Ethereum version of the V parameter
-func normaliseV(s Signer, v *big.Int) byte {
-	if s, ok := s.(EIP155Signer); ok {
-		stdV := v.BitLen() <= 8 && (v.Uint64() == 27 || v.Uint64() == 28)
-		if s.chainId.BitLen() > 0 && !stdV {
-			nv := byte((new(big.Int).Sub(v, s.chainIdMul).Uint64()) - 35 + 27)
-			return nv
-		}
-	}
-	return byte(v.Uint64())
-}
-
-// deriveChainId derives the chain id from the given v parameter
-func deriveChainId(v *big.Int) *big.Int {
-	if v.BitLen() <= 64 {
-		v := v.Uint64()
-		if v == 27 || v == 28 {
-			return new(big.Int)
-		}
-		return new(big.Int).SetUint64((v - 35) / 2)
-	}
-	v = new(big.Int).Sub(v, big.NewInt(35))
-	return v.Div(v, big.NewInt(2))
-}

core/types/transaction_signing_test.go

@@ -1,33 +0,0 @@
-package types
-
-import (
-	"math/big"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/common"
-)
-
-func TestChainId(t *testing.T) {
-	key, _ := defaultTestKey()
-
-	tx := NewTransaction(0, common.Address{}, new(big.Int), new(big.Int), new(big.Int), nil)
-	tx.SetSigner(NewEIP155Signer(big.NewInt(1)))
-
-	var err error
-	tx, err = tx.SignECDSA(key)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	tx.SetSigner(NewEIP155Signer(big.NewInt(2)))
-	_, err = tx.From()
-	if err != ErrInvalidChainId {
-		t.Error("expected error:", ErrInvalidChainId)
-	}
-
-	tx.SetSigner(NewEIP155Signer(big.NewInt(1)))
-	_, err = tx.From()
-	if err != nil {
-		t.Error("expected no error")
-	}
-}

core/types/transaction_test.go

@@ -128,25 +128,15 @@ func TestTransactionPriceNonceSort(t *testing.T) {
 		keys[i], _ = crypto.GenerateKey()
 	}
 	// Generate a batch of transactions with overlapping values, but shifted nonces
-	groups := map[common.Address]Transactions{}
+	txs := []*Transaction{}
 	for start, key := range keys {
-		addr := crypto.PubkeyToAddress(key.PublicKey)
 		for i := 0; i < 25; i++ {
 			tx, _ := NewTransaction(uint64(start+i), common.Address{}, big.NewInt(100), big.NewInt(100), big.NewInt(int64(start+i)), nil).SignECDSA(key)
-			groups[addr] = append(groups[addr], tx)
+			txs = append(txs, tx)
 		}
 	}
 	// Sort the transactions and cross check the nonce ordering
-	txset := NewTransactionsByPriceAndNonce(groups)
-
-	txs := Transactions{}
-	for {
-		if tx := txset.Peek(); tx != nil {
-			txs = append(txs, tx)
-			txset.Shift()
-		}
-		break
-	}
+	SortByPriceAndNonce(txs)
 	for i, txi := range txs {
 		fromi, _ := txi.From()
 

core/vm/contract.go

@@ -27,7 +27,7 @@ type ContractRef interface {
 	ReturnGas(*big.Int, *big.Int)
 	Address() common.Address
 	Value() *big.Int
-	SetCode(common.Hash, []byte)
+	SetCode([]byte)
 	ForEachStorage(callback func(key, value common.Hash) bool)
 }
 
@@ -44,9 +44,8 @@ type Contract struct {
 	jumpdests destinations // result of JUMPDEST analysis.
 
 	Code     []byte
-	CodeHash common.Hash
-	CodeAddr *common.Address
 	Input    []byte
+	CodeAddr *common.Address
 
 	value, Gas, UsedGas, Price *big.Int
 
@@ -144,16 +143,14 @@ func (c *Contract) Value() *big.Int {
 }
 
 // SetCode sets the code to the contract
-func (self *Contract) SetCode(hash common.Hash, code []byte) {
+func (self *Contract) SetCode(code []byte) {
 	self.Code = code
-	self.CodeHash = hash
 }
 
 // SetCallCode sets the code of the contract and address of the backing data
 // object
-func (self *Contract) SetCallCode(addr *common.Address, hash common.Hash, code []byte) {
+func (self *Contract) SetCallCode(addr *common.Address, code []byte) {
 	self.Code = code
-	self.CodeHash = hash
 	self.CodeAddr = addr
 }
 

core/vm/contracts.go

@@ -95,7 +95,7 @@ func ecrecoverFunc(in []byte) []byte {
 
 	// tighter sig s values in homestead only apply to tx sigs
 	if !crypto.ValidateSignatureValues(v, r, s, false) {
-		glog.V(logger.Detail).Infof("ECRECOVER error: v, r or s value invalid")
+		glog.V(logger.Debug).Infof("EC RECOVER FAIL: v, r or s value invalid")
 		return nil
 	}
 
@@ -106,7 +106,7 @@ func ecrecoverFunc(in []byte) []byte {
 	pubKey, err := crypto.Ecrecover(in[:32], rsv)
 	// make sure the public key is a valid one
 	if err != nil {
-		glog.V(logger.Detail).Infoln("ECRECOVER error: ", err)
+		glog.V(logger.Error).Infof("EC RECOVER FAIL: ", err)
 		return nil
 	}
 

core/vm/environment.go

@@ -20,20 +20,25 @@ import (
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/params"
 )
 
+// RuleSet is an interface that defines the current rule set during the
+// execution of the EVM instructions (e.g. whether it's homestead)
+type RuleSet interface {
+	IsHomestead(*big.Int) bool
+}
+
 // Environment is an EVM requirement and helper which allows access to outside
 // information such as states.
 type Environment interface {
 	// The current ruleset
-	ChainConfig() *params.ChainConfig
+	RuleSet() RuleSet
 	// The state database
 	Db() Database
 	// Creates a restorable snapshot
-	SnapshotDatabase() int
+	MakeSnapshot() Database
 	// Set database to previous snapshot
-	RevertToSnapshot(int)
+	SetSnapshot(Database)
 	// Address of the original invoker (first occurrence of the VM invoker)
 	Origin() common.Address
 	// The block number this VM is invoked on
@@ -89,8 +94,6 @@ type Database interface {
 	GetNonce(common.Address) uint64
 	SetNonce(common.Address, uint64)
 
-	GetCodeHash(common.Address) common.Hash
-	GetCodeSize(common.Address) int
 	GetCode(common.Address) []byte
 	SetCode(common.Address, []byte)
 
@@ -100,13 +103,9 @@ type Database interface {
 	GetState(common.Address, common.Hash) common.Hash
 	SetState(common.Address, common.Hash, common.Hash)
 
-	Suicide(common.Address) bool
-	HasSuicided(common.Address) bool
-
-	// Exist reports whether the given account exists in state.
-	// Notably this should also return true for suicided accounts.
+	Delete(common.Address) bool
 	Exist(common.Address) bool
-	Empty(common.Address) bool
+	IsDeleted(common.Address) bool
 }
 
 // Account represents a contract or basic ethereum account.
@@ -118,7 +117,7 @@ type Account interface {
 	Balance() *big.Int
 	Address() common.Address
 	ReturnGas(*big.Int, *big.Int)
-	SetCode(common.Hash, []byte)
+	SetCode([]byte)
 	ForEachStorage(cb func(key, value common.Hash) bool)
 	Value() *big.Int
 }

core/vm/gas.go

@@ -35,27 +35,8 @@ var (
 	GasStop   = big.NewInt(0)
 
 	GasContractByte = big.NewInt(200)
-
-	n64 = big.NewInt(64)
 )
 
-// calcGas returns the actual gas cost of the call.
-//
-// The cost of gas was changed during the homestead price change HF. To allow for EIP150
-// to be implemented. The returned gas is gas - base * 63 / 64.
-func callGas(gasTable params.GasTable, availableGas, base, callCost *big.Int) *big.Int {
-	if gasTable.CreateBySuicide != nil {
-		availableGas = new(big.Int).Sub(availableGas, base)
-		g := new(big.Int).Div(availableGas, n64)
-		g.Sub(availableGas, g)
-
-		if g.Cmp(callCost) < 0 {
-			return g
-		}
-	}
-	return callCost
-}
-
 // baseCheck checks for any stack error underflows
 func baseCheck(op OpCode, stack *stack, gas *big.Int) error {
 	// PUSH and DUP are a bit special. They all cost the same but we do want to have checking on stack push limit
@@ -146,19 +127,18 @@ var _baseCheck = map[OpCode]req{
 	MSIZE:        {0, GasQuickStep, 1},
 	GAS:          {0, GasQuickStep, 1},
 	BLOCKHASH:    {1, GasExtStep, 1},
-	BALANCE:      {1, Zero, 1},
-	EXTCODESIZE:  {1, Zero, 1},
-	EXTCODECOPY:  {4, Zero, 0},
+	BALANCE:      {1, GasExtStep, 1},
+	EXTCODESIZE:  {1, GasExtStep, 1},
+	EXTCODECOPY:  {4, GasExtStep, 0},
 	SLOAD:        {1, params.SloadGas, 1},
 	SSTORE:       {2, Zero, 0},
 	SHA3:         {2, params.Sha3Gas, 1},
 	CREATE:       {3, params.CreateGas, 1},
-	// Zero is calculated in the gasSwitch
-	CALL:         {7, Zero, 1},
-	CALLCODE:     {7, Zero, 1},
-	DELEGATECALL: {6, Zero, 1},
-	SUICIDE:      {1, Zero, 0},
+	CALL:         {7, params.CallGas, 1},
+	CALLCODE:     {7, params.CallGas, 1},
+	DELEGATECALL: {6, params.CallGas, 1},
 	JUMPDEST:     {0, params.JumpdestGas, 0},
+	SUICIDE:      {1, Zero, 0},
 	RETURN:       {2, Zero, 0},
 	PUSH1:        {0, GasFastestStep, 1},
 	DUP1:         {0, Zero, 1},

core/vm/instructions.go

@@ -363,7 +363,7 @@ func opCalldataCopy(instr instruction, pc *uint64, env Environment, contract *Co
 
 func opExtCodeSize(instr instruction, pc *uint64, env Environment, contract *Contract, memory *Memory, stack *stack) {
 	addr := common.BigToAddress(stack.pop())
-	l := big.NewInt(int64(env.Db().GetCodeSize(addr)))
+	l := big.NewInt(int64(len(env.Db().GetCode(addr))))
 	stack.push(l)
 }
 
@@ -514,18 +514,13 @@ func opCreate(instr instruction, pc *uint64, env Environment, contract *Contract
 		input        = memory.Get(offset.Int64(), size.Int64())
 		gas          = new(big.Int).Set(contract.Gas)
 	)
-	if env.ChainConfig().IsEIP150(env.BlockNumber()) {
-		gas.Div(gas, n64)
-		gas = gas.Sub(contract.Gas, gas)
-	}
-
-	contract.UseGas(gas)
+	contract.UseGas(contract.Gas)
 	_, addr, suberr := env.Create(contract, input, gas, contract.Price, value)
 	// Push item on the stack based on the returned error. If the ruleset is
 	// homestead we must check for CodeStoreOutOfGasError (homestead only
 	// rule) and treat as an error, if the ruleset is frontier we must
 	// ignore this error and pretend the operation was successful.
-	if env.ChainConfig().IsHomestead(env.BlockNumber()) && suberr == CodeStoreOutOfGasError {
+	if env.RuleSet().IsHomestead(env.BlockNumber()) && suberr == CodeStoreOutOfGasError {
 		stack.push(new(big.Int))
 	} else if suberr != nil && suberr != CodeStoreOutOfGasError {
 		stack.push(new(big.Int))
@@ -619,7 +614,7 @@ func opSuicide(instr instruction, pc *uint64, env Environment, contract *Contrac
 	balance := env.Db().GetBalance(contract.Address())
 	env.Db().AddBalance(common.BigToAddress(stack.pop()), balance)
 
-	env.Db().Suicide(contract.Address())
+	env.Db().Delete(contract.Address())
 }
 
 // following functions are used by the instruction jump  table

core/vm/jit.go

@@ -319,7 +319,7 @@ func runProgram(program *Program, pcstart uint64, mem *Memory, stack *stack, env
 		}()
 	}
 
-	homestead := env.ChainConfig().IsHomestead(env.BlockNumber())
+	homestead := env.RuleSet().IsHomestead(env.BlockNumber())
 	for pc < uint64(len(program.instructions)) {
 		instrCount++
 
@@ -425,7 +425,7 @@ func jitCalculateGasAndSize(env Environment, contract *Contract, instr instructi
 		}
 		gas.Set(g)
 	case SUICIDE:
-		if !statedb.HasSuicided(contract.Address()) {
+		if !statedb.IsDeleted(contract.Address()) {
 			statedb.AddRefund(params.SuicideRefundGas)
 		}
 	case MLOAD:

core/vm/jit_test.go

@@ -23,7 +23,6 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/params"
 )
 
 const maxRun = 1000
@@ -136,7 +135,7 @@ func (account) SetNonce(uint64)                                     {}
 func (account) Balance() *big.Int                                   { return nil }
 func (account) Address() common.Address                             { return common.Address{} }
 func (account) ReturnGas(*big.Int, *big.Int)                        {}
-func (account) SetCode(common.Hash, []byte)                         {}
+func (account) SetCode([]byte)                                      {}
 func (account) ForEachStorage(cb func(key, value common.Hash) bool) {}
 
 func runVmBench(test vmBench, b *testing.B) {
@@ -176,9 +175,7 @@ func NewEnv(noJit, forceJit bool) *Env {
 	return env
 }
 
-func (self *Env) ChainConfig() *params.ChainConfig {
-	return params.TestChainConfig
-}
+func (self *Env) RuleSet() RuleSet       { return ruleSet{new(big.Int)} }
 func (self *Env) Vm() Vm                 { return self.evm }
 func (self *Env) Origin() common.Address { return common.Address{} }
 func (self *Env) BlockNumber() *big.Int  { return big.NewInt(0) }
@@ -190,8 +187,8 @@ func (self *Env) StructLogs() []StructLog {
 
 //func (self *Env) PrevHash() []byte      { return self.parent }
 func (self *Env) Coinbase() common.Address { return common.Address{} }
-func (self *Env) SnapshotDatabase() int    { return 0 }
-func (self *Env) RevertToSnapshot(int)     {}
+func (self *Env) MakeSnapshot() Database   { return nil }
+func (self *Env) SetSnapshot(Database)     {}
 func (self *Env) Time() *big.Int           { return big.NewInt(time.Now().Unix()) }
 func (self *Env) Difficulty() *big.Int     { return big.NewInt(0) }
 func (self *Env) Db() Database             { return nil }

core/vm/jump_table.go

@@ -16,11 +16,7 @@
 
 package vm
 
-import (
-	"math/big"
-
-	"github.com/ethereum/go-ethereum/params"
-)
+import "math/big"
 
 type jumpPtr struct {
 	fn    instrFn
@@ -29,7 +25,7 @@ type jumpPtr struct {
 
 type vmJumpTable [256]jumpPtr
 
-func newJumpTable(ruleset *params.ChainConfig, blockNumber *big.Int) vmJumpTable {
+func newJumpTable(ruleset RuleSet, blockNumber *big.Int) vmJumpTable {
 	var jumpTable vmJumpTable
 
 	// when initialising a new VM execution we must first check the homestead

core/vm/jump_table_test.go

@@ -19,18 +19,16 @@ package vm
 import (
 	"math/big"
 	"testing"
-
-	"github.com/ethereum/go-ethereum/params"
 )
 
 func TestInit(t *testing.T) {
-	jumpTable := newJumpTable(&params.ChainConfig{HomesteadBlock: big.NewInt(1)}, big.NewInt(0))
+	jumpTable := newJumpTable(ruleSet{big.NewInt(1)}, big.NewInt(0))
 	if jumpTable[DELEGATECALL].valid {
 		t.Error("Expected DELEGATECALL not to be present")
 	}
 
 	for _, n := range []int64{1, 2, 100} {
-		jumpTable := newJumpTable(&params.ChainConfig{HomesteadBlock: big.NewInt(1)}, big.NewInt(n))
+		jumpTable := newJumpTable(ruleSet{big.NewInt(1)}, big.NewInt(n))
 		if !jumpTable[DELEGATECALL].valid {
 			t.Error("Expected DELEGATECALL to be present for block", n)
 		}

core/vm/logger_test.go

@@ -30,7 +30,7 @@ type dummyContractRef struct {
 func (dummyContractRef) ReturnGas(*big.Int, *big.Int) {}
 func (dummyContractRef) Address() common.Address      { return common.Address{} }
 func (dummyContractRef) Value() *big.Int              { return new(big.Int) }
-func (dummyContractRef) SetCode(common.Hash, []byte)  {}
+func (dummyContractRef) SetCode([]byte)               {}
 func (d *dummyContractRef) ForEachStorage(callback func(key, value common.Hash) bool) {
 	d.calledForEach = true
 }

core/vm/runtime/env.go

@@ -23,14 +23,13 @@ import (
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/vm"
-	"github.com/ethereum/go-ethereum/params"
 )
 
 // Env is a basic runtime environment required for running the EVM.
 type Env struct {
-	chainConfig *params.ChainConfig
-	depth       int
-	state       *state.StateDB
+	ruleSet vm.RuleSet
+	depth   int
+	state   *state.StateDB
 
 	origin   common.Address
 	coinbase common.Address
@@ -50,14 +49,14 @@ type Env struct {
 // NewEnv returns a new vm.Environment
 func NewEnv(cfg *Config, state *state.StateDB) vm.Environment {
 	env := &Env{
-		chainConfig: cfg.ChainConfig,
-		state:       state,
-		origin:      cfg.Origin,
-		coinbase:    cfg.Coinbase,
-		number:      cfg.BlockNumber,
-		time:        cfg.Time,
-		difficulty:  cfg.Difficulty,
-		gasLimit:    cfg.GasLimit,
+		ruleSet:    cfg.RuleSet,
+		state:      state,
+		origin:     cfg.Origin,
+		coinbase:   cfg.Coinbase,
+		number:     cfg.BlockNumber,
+		time:       cfg.Time,
+		difficulty: cfg.Difficulty,
+		gasLimit:   cfg.GasLimit,
 	}
 	env.evm = vm.New(env, vm.Config{
 		Debug:     cfg.Debug,
@@ -80,16 +79,16 @@ func (self *Env) AddStructLog(log vm.StructLog) {
 	self.logs = append(self.logs, log)
 }
 
-func (self *Env) ChainConfig() *params.ChainConfig { return self.chainConfig }
-func (self *Env) Vm() vm.Vm                        { return self.evm }
-func (self *Env) Origin() common.Address           { return self.origin }
-func (self *Env) BlockNumber() *big.Int            { return self.number }
-func (self *Env) Coinbase() common.Address         { return self.coinbase }
-func (self *Env) Time() *big.Int                   { return self.time }
-func (self *Env) Difficulty() *big.Int             { return self.difficulty }
-func (self *Env) Db() vm.Database                  { return self.state }
-func (self *Env) GasLimit() *big.Int               { return self.gasLimit }
-func (self *Env) VmType() vm.Type                  { return vm.StdVmTy }
+func (self *Env) RuleSet() vm.RuleSet      { return self.ruleSet }
+func (self *Env) Vm() vm.Vm                { return self.evm }
+func (self *Env) Origin() common.Address   { return self.origin }
+func (self *Env) BlockNumber() *big.Int    { return self.number }
+func (self *Env) Coinbase() common.Address { return self.coinbase }
+func (self *Env) Time() *big.Int           { return self.time }
+func (self *Env) Difficulty() *big.Int     { return self.difficulty }
+func (self *Env) Db() vm.Database          { return self.state }
+func (self *Env) GasLimit() *big.Int       { return self.gasLimit }
+func (self *Env) VmType() vm.Type          { return vm.StdVmTy }
 func (self *Env) GetHash(n uint64) common.Hash {
 	return self.getHashFn(n)
 }
@@ -101,11 +100,11 @@ func (self *Env) SetDepth(i int) { self.depth = i }
 func (self *Env) CanTransfer(from common.Address, balance *big.Int) bool {
 	return self.state.GetBalance(from).Cmp(balance) >= 0
 }
-func (self *Env) SnapshotDatabase() int {
-	return self.state.Snapshot()
+func (self *Env) MakeSnapshot() vm.Database {
+	return self.state.Copy()
 }
-func (self *Env) RevertToSnapshot(snapshot int) {
-	self.state.RevertToSnapshot(snapshot)
+func (self *Env) SetSnapshot(copy vm.Database) {
+	self.state.Set(copy.(*state.StateDB))
 }
 
 func (self *Env) Transfer(from, to vm.Account, amount *big.Int) {

core/vm/runtime/runtime.go

@@ -22,23 +22,20 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/params"
 )
 
 // The default, always homestead, rule set for the vm env
 type ruleSet struct{}
 
 func (ruleSet) IsHomestead(*big.Int) bool { return true }
-func (ruleSet) GasTable(*big.Int) params.GasTable {
-	return params.GasTableHomesteadGasRepriceFork
-}
 
 // Config is a basic type specifying certain configuration flags for running
 // the EVM.
 type Config struct {
-	ChainConfig *params.ChainConfig
+	RuleSet     vm.RuleSet
 	Difficulty  *big.Int
 	Origin      common.Address
 	Coinbase    common.Address
@@ -56,8 +53,8 @@ type Config struct {
 
 // sets defaults on the config
 func setDefaults(cfg *Config) {
-	if cfg.ChainConfig == nil {
-		cfg.ChainConfig = params.TestChainConfig
+	if cfg.RuleSet == nil {
+		cfg.RuleSet = ruleSet{}
 	}
 
 	if cfg.Difficulty == nil {
@@ -107,7 +104,7 @@ func Execute(code, input []byte, cfg *Config) ([]byte, *state.StateDB, error) {
 		receiver = cfg.State.CreateAccount(common.StringToAddress("contract"))
 	)
 	// set the receiver's (the executing contract) code for execution.
-	receiver.SetCode(crypto.Keccak256Hash(code), code)
+	receiver.SetCode(code)
 
 	// Call the code with the given configuration.
 	ret, err := vmenv.Call(

core/vm/util_test.go

@@ -16,17 +16,10 @@
 
 package vm
 
-import (
-	"math/big"
-
-	"github.com/ethereum/go-ethereum/params"
-)
+import "math/big"
 
 type ruleSet struct {
 	hs *big.Int
 }
 
 func (r ruleSet) IsHomestead(n *big.Int) bool { return n.Cmp(r.hs) >= 0 }
-func (r ruleSet) GasTable(*big.Int) params.GasTable {
-	return params.GasTableHomestead
-}

core/vm/vm.go

@@ -44,8 +44,8 @@ type EVM struct {
 	env       Environment
 	jumpTable vmJumpTable
 	cfg       Config
-	logger    *Logger
-	gasTable  params.GasTable
+
+	logger *Logger
 }
 
 // New returns a new instance of the EVM.
@@ -57,10 +57,9 @@ func New(env Environment, cfg Config) *EVM {
 
 	return &EVM{
 		env:       env,
-		jumpTable: newJumpTable(env.ChainConfig(), env.BlockNumber()),
+		jumpTable: newJumpTable(env.RuleSet(), env.BlockNumber()),
 		cfg:       cfg,
 		logger:    logger,
-		gasTable:  env.ChainConfig().GasTable(env.BlockNumber()),
 	}
 }
 
@@ -80,11 +79,10 @@ func (evm *EVM) Run(contract *Contract, input []byte) (ret []byte, err error) {
 		return nil, nil
 	}
 
-	codehash := contract.CodeHash // codehash is used when doing jump dest caching
-	if codehash == (common.Hash{}) {
-		codehash = crypto.Keccak256Hash(contract.Code)
-	}
-	var program *Program
+	var (
+		codehash = crypto.Keccak256Hash(contract.Code) // codehash is used when doing jump dest caching
+		program  *Program
+	)
 	if evm.cfg.EnableJit {
 		// If the JIT is enabled check the status of the JIT program,
 		// if it doesn't exist compile a new program in a separate
@@ -177,9 +175,8 @@ func (evm *EVM) Run(contract *Contract, input []byte) (ret []byte, err error) {
 
 		// Get the memory location of pc
 		op = contract.GetOp(pc)
-		//fmt.Printf("OP %d %v\n", op, op)
 		// calculate the new memory size and gas price for the current executing opcode
-		newMemSize, cost, err = calculateGasAndSize(evm.gasTable, evm.env, contract, caller, op, statedb, mem, stack)
+		newMemSize, cost, err = calculateGasAndSize(evm.env, contract, caller, op, statedb, mem, stack)
 		if err != nil {
 			return nil, err
 		}
@@ -244,7 +241,7 @@ func (evm *EVM) Run(contract *Contract, input []byte) (ret []byte, err error) {
 
 // calculateGasAndSize calculates the required given the opcode and stack items calculates the new memorysize for
 // the operation. This does not reduce gas or resizes the memory.
-func calculateGasAndSize(gasTable params.GasTable, env Environment, contract *Contract, caller ContractRef, op OpCode, statedb Database, mem *Memory, stack *stack) (*big.Int, *big.Int, error) {
+func calculateGasAndSize(env Environment, contract *Contract, caller ContractRef, op OpCode, statedb Database, mem *Memory, stack *stack) (*big.Int, *big.Int, error) {
 	var (
 		gas                 = new(big.Int)
 		newMemSize *big.Int = new(big.Int)
@@ -256,34 +253,6 @@ func calculateGasAndSize(gasTable params.GasTable, env Environment, contract *Co
 
 	// stack Check, memory resize & gas phase
 	switch op {
-	case SUICIDE:
-		// EIP150 homestead gas reprice fork:
-		if gasTable.CreateBySuicide != nil {
-			gas.Set(gasTable.Suicide)
-			var (
-				address = common.BigToAddress(stack.data[len(stack.data)-1])
-				eip158  = env.ChainConfig().IsEIP158(env.BlockNumber())
-			)
-
-			if eip158 {
-				// if empty and transfers value
-				if env.Db().Empty(address) && statedb.GetBalance(contract.Address()).BitLen() > 0 {
-					gas.Add(gas, gasTable.CreateBySuicide)
-				}
-			} else if !env.Db().Exist(address) {
-				gas.Add(gas, gasTable.CreateBySuicide)
-			}
-		}
-
-		if !statedb.HasSuicided(contract.Address()) {
-			statedb.AddRefund(params.SuicideRefundGas)
-		}
-	case EXTCODESIZE:
-		gas.Set(gasTable.ExtcodeSize)
-	case BALANCE:
-		gas.Set(gasTable.Balance)
-	case SLOAD:
-		gas.Set(gasTable.SLoad)
 	case SWAP1, SWAP2, SWAP3, SWAP4, SWAP5, SWAP6, SWAP7, SWAP8, SWAP9, SWAP10, SWAP11, SWAP12, SWAP13, SWAP14, SWAP15, SWAP16:
 		n := int(op - SWAP1 + 2)
 		err := stack.require(n)
@@ -312,11 +281,8 @@ func calculateGasAndSize(gasTable params.GasTable, env Environment, contract *Co
 		gas.Add(gas, new(big.Int).Mul(mSize, params.LogDataGas))
 
 		newMemSize = calcMemSize(mStart, mSize)
-
-		quadMemGas(mem, newMemSize, gas)
 	case EXP:
-		expByteLen := int64((stack.data[stack.len()-2].BitLen() + 7) / 8)
-		gas.Add(gas, new(big.Int).Mul(big.NewInt(expByteLen), gasTable.ExpByte))
+		gas.Add(gas, new(big.Int).Mul(big.NewInt(int64(len(stack.data[stack.len()-2].Bytes()))), params.ExpByteGas))
 	case SSTORE:
 		err := stack.require(2)
 		if err != nil {
@@ -343,109 +309,67 @@ func calculateGasAndSize(gasTable params.GasTable, env Environment, contract *Co
 			g = params.SstoreClearGas
 		}
 		gas.Set(g)
+	case SUICIDE:
+		if !statedb.IsDeleted(contract.Address()) {
+			statedb.AddRefund(params.SuicideRefundGas)
+		}
 	case MLOAD:
 		newMemSize = calcMemSize(stack.peek(), u256(32))
-		quadMemGas(mem, newMemSize, gas)
 	case MSTORE8:
 		newMemSize = calcMemSize(stack.peek(), u256(1))
-		quadMemGas(mem, newMemSize, gas)
 	case MSTORE:
 		newMemSize = calcMemSize(stack.peek(), u256(32))
-		quadMemGas(mem, newMemSize, gas)
 	case RETURN:
 		newMemSize = calcMemSize(stack.peek(), stack.data[stack.len()-2])
-		quadMemGas(mem, newMemSize, gas)
 	case SHA3:
 		newMemSize = calcMemSize(stack.peek(), stack.data[stack.len()-2])
 
 		words := toWordSize(stack.data[stack.len()-2])
 		gas.Add(gas, words.Mul(words, params.Sha3WordGas))
-
-		quadMemGas(mem, newMemSize, gas)
 	case CALLDATACOPY:
 		newMemSize = calcMemSize(stack.peek(), stack.data[stack.len()-3])
 
 		words := toWordSize(stack.data[stack.len()-3])
 		gas.Add(gas, words.Mul(words, params.CopyGas))
-
-		quadMemGas(mem, newMemSize, gas)
 	case CODECOPY:
 		newMemSize = calcMemSize(stack.peek(), stack.data[stack.len()-3])
 
 		words := toWordSize(stack.data[stack.len()-3])
 		gas.Add(gas, words.Mul(words, params.CopyGas))
-
-		quadMemGas(mem, newMemSize, gas)
 	case EXTCODECOPY:
-		gas.Set(gasTable.ExtcodeCopy)
-
 		newMemSize = calcMemSize(stack.data[stack.len()-2], stack.data[stack.len()-4])
 
 		words := toWordSize(stack.data[stack.len()-4])
 		gas.Add(gas, words.Mul(words, params.CopyGas))
 
-		quadMemGas(mem, newMemSize, gas)
 	case CREATE:
 		newMemSize = calcMemSize(stack.data[stack.len()-2], stack.data[stack.len()-3])
-
-		quadMemGas(mem, newMemSize, gas)
 	case CALL, CALLCODE:
-		gas.Set(gasTable.Calls)
+		gas.Add(gas, stack.data[stack.len()-1])
 
-		transfersValue := stack.data[len(stack.data)-3].BitLen() > 0
 		if op == CALL {
-			var (
-				address = common.BigToAddress(stack.data[len(stack.data)-2])
-				eip158  = env.ChainConfig().IsEIP158(env.BlockNumber())
-			)
-			if eip158 {
-				if env.Db().Empty(address) && transfersValue {
-					gas.Add(gas, params.CallNewAccountGas)
-				}
-			} else if !env.Db().Exist(address) {
+			if !env.Db().Exist(common.BigToAddress(stack.data[stack.len()-2])) {
 				gas.Add(gas, params.CallNewAccountGas)
 			}
 		}
-		if transfersValue {
+
+		if len(stack.data[stack.len()-3].Bytes()) > 0 {
 			gas.Add(gas, params.CallValueTransferGas)
 		}
+
 		x := calcMemSize(stack.data[stack.len()-6], stack.data[stack.len()-7])
 		y := calcMemSize(stack.data[stack.len()-4], stack.data[stack.len()-5])
 
 		newMemSize = common.BigMax(x, y)
-
-		quadMemGas(mem, newMemSize, gas)
-
-		cg := callGas(gasTable, contract.Gas, gas, stack.data[stack.len()-1])
-		// Replace the stack item with the new gas calculation. This means that
-		// either the original item is left on the stack or the item is replaced by:
-		// (availableGas - gas) * 63 / 64
-		// We replace the stack item so that it's available when the opCall instruction is
-		// called. This information is otherwise lost due to the dependency on *current*
-		// available gas.
-		stack.data[stack.len()-1] = cg
-		gas.Add(gas, cg)
-
 	case DELEGATECALL:
-		gas.Set(gasTable.Calls)
+		gas.Add(gas, stack.data[stack.len()-1])
 
 		x := calcMemSize(stack.data[stack.len()-5], stack.data[stack.len()-6])
 		y := calcMemSize(stack.data[stack.len()-3], stack.data[stack.len()-4])
 
 		newMemSize = common.BigMax(x, y)
-
-		quadMemGas(mem, newMemSize, gas)
-
-		cg := callGas(gasTable, contract.Gas, gas, stack.data[stack.len()-1])
-		// Replace the stack item with the new gas calculation. This means that
-		// either the original item is left on the stack or the item is replaced by:
-		// (availableGas - gas) * 63 / 64
-		// We replace the stack item so that it's available when the opCall instruction is
-		// called.
-		stack.data[stack.len()-1] = cg
-		gas.Add(gas, cg)
-
 	}
+	quadMemGas(mem, newMemSize, gas)
 
 	return newMemSize, gas, nil
 }

core/vm_env.go

@@ -23,7 +23,6 @@ import (
 	"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/params"
 )
 
 // GetHashFn returns a function for which the VM env can query block hashes through
@@ -42,11 +41,11 @@ func GetHashFn(ref common.Hash, chain *BlockChain) func(n uint64) common.Hash {
 }
 
 type VMEnv struct {
-	chainConfig *params.ChainConfig // Chain configuration
-	state       *state.StateDB      // State to use for executing
-	evm         *vm.EVM             // The Ethereum Virtual Machine
-	depth       int                 // Current execution depth
-	msg         Message             // Message appliod
+	chainConfig *ChainConfig   // Chain configuration
+	state       *state.StateDB // State to use for executing
+	evm         *vm.EVM        // The Ethereum Virtual Machine
+	depth       int            // Current execution depth
+	msg         Message        // Message appliod
 
 	header    *types.Header            // Header information
 	chain     *BlockChain              // Blockchain handle
@@ -54,7 +53,7 @@ type VMEnv struct {
 	getHashFn func(uint64) common.Hash // getHashFn callback is used to retrieve block hashes
 }
 
-func NewEnv(state *state.StateDB, chainConfig *params.ChainConfig, chain *BlockChain, msg Message, header *types.Header, cfg vm.Config) *VMEnv {
+func NewEnv(state *state.StateDB, chainConfig *ChainConfig, chain *BlockChain, msg Message, header *types.Header, cfg vm.Config) *VMEnv {
 	env := &VMEnv{
 		chainConfig: chainConfig,
 		chain:       chain,
@@ -73,18 +72,18 @@ func NewEnv(state *state.StateDB, chainConfig *params.ChainConfig, chain *BlockC
 	return env
 }
 
-func (self *VMEnv) ChainConfig() *params.ChainConfig { return self.chainConfig }
-func (self *VMEnv) Vm() vm.Vm                        { return self.evm }
-func (self *VMEnv) Origin() common.Address           { f, _ := self.msg.From(); return f }
-func (self *VMEnv) BlockNumber() *big.Int            { return self.header.Number }
-func (self *VMEnv) Coinbase() common.Address         { return self.header.Coinbase }
-func (self *VMEnv) Time() *big.Int                   { return self.header.Time }
-func (self *VMEnv) Difficulty() *big.Int             { return self.header.Difficulty }
-func (self *VMEnv) GasLimit() *big.Int               { return self.header.GasLimit }
-func (self *VMEnv) Value() *big.Int                  { return self.msg.Value() }
-func (self *VMEnv) Db() vm.Database                  { return self.state }
-func (self *VMEnv) Depth() int                       { return self.depth }
-func (self *VMEnv) SetDepth(i int)                   { self.depth = i }
+func (self *VMEnv) RuleSet() vm.RuleSet      { return self.chainConfig }
+func (self *VMEnv) Vm() vm.Vm                { return self.evm }
+func (self *VMEnv) Origin() common.Address   { f, _ := self.msg.From(); return f }
+func (self *VMEnv) BlockNumber() *big.Int    { return self.header.Number }
+func (self *VMEnv) Coinbase() common.Address { return self.header.Coinbase }
+func (self *VMEnv) Time() *big.Int           { return self.header.Time }
+func (self *VMEnv) Difficulty() *big.Int     { return self.header.Difficulty }
+func (self *VMEnv) GasLimit() *big.Int       { return self.header.GasLimit }
+func (self *VMEnv) Value() *big.Int          { return self.msg.Value() }
+func (self *VMEnv) Db() vm.Database          { return self.state }
+func (self *VMEnv) Depth() int               { return self.depth }
+func (self *VMEnv) SetDepth(i int)           { self.depth = i }
 func (self *VMEnv) GetHash(n uint64) common.Hash {
 	return self.getHashFn(n)
 }
@@ -96,12 +95,12 @@ func (self *VMEnv) CanTransfer(from common.Address, balance *big.Int) bool {
 	return self.state.GetBalance(from).Cmp(balance) >= 0
 }
 
-func (self *VMEnv) SnapshotDatabase() int {
-	return self.state.Snapshot()
+func (self *VMEnv) MakeSnapshot() vm.Database {
+	return self.state.Copy()
 }
 
-func (self *VMEnv) RevertToSnapshot(snapshot int) {
-	self.state.RevertToSnapshot(snapshot)
+func (self *VMEnv) SetSnapshot(copy vm.Database) {
+	self.state.Set(copy.(*state.StateDB))
 }
 
 func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) {

crypto/sha3/keccakf.go

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//  +build !amd64 appengine gccgo
-
 package sha3
 
 // rc stores the round constants for use in the ι step.

crypto/sha3/keccakf_amd64.go

@@ -1,13 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build amd64,!appengine,!gccgo
-
-package sha3
-
-// This function is implemented in keccakf_amd64.s.
-
-//go:noescape
-
-func keccakF1600(state *[25]uint64)

crypto/sha3/keccakf_amd64.s

@@ -1,392 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build amd64,!appengine,!gccgo
-
-// This code was translated into a form compatible with 6a from the public
-// domain sources at https://github.com/gvanas/KeccakCodePackage
-
-// Offsets in state
-#define _ba  (0*8)
-#define _be  (1*8)
-#define _bi  (2*8)
-#define _bo  (3*8)
-#define _bu  (4*8)
-#define _ga  (5*8)
-#define _ge  (6*8)
-#define _gi  (7*8)
-#define _go  (8*8)
-#define _gu  (9*8)
-#define _ka (10*8)
-#define _ke (11*8)
-#define _ki (12*8)
-#define _ko (13*8)
-#define _ku (14*8)
-#define _ma (15*8)
-#define _me (16*8)
-#define _mi (17*8)
-#define _mo (18*8)
-#define _mu (19*8)
-#define _sa (20*8)
-#define _se (21*8)
-#define _si (22*8)
-#define _so (23*8)
-#define _su (24*8)
-
-// Temporary registers
-#define rT1  AX
-
-// Round vars
-#define rpState DI
-#define rpStack SP
-
-#define rDa BX
-#define rDe CX
-#define rDi DX
-#define rDo R8
-#define rDu R9
-
-#define rBa R10
-#define rBe R11
-#define rBi R12
-#define rBo R13
-#define rBu R14
-
-#define rCa SI
-#define rCe BP
-#define rCi rBi
-#define rCo rBo
-#define rCu R15
-
-#define MOVQ_RBI_RCE MOVQ rBi, rCe
-#define XORQ_RT1_RCA XORQ rT1, rCa
-#define XORQ_RT1_RCE XORQ rT1, rCe
-#define XORQ_RBA_RCU XORQ rBa, rCu
-#define XORQ_RBE_RCU XORQ rBe, rCu
-#define XORQ_RDU_RCU XORQ rDu, rCu
-#define XORQ_RDA_RCA XORQ rDa, rCa
-#define XORQ_RDE_RCE XORQ rDe, rCe
-
-#define mKeccakRound(iState, oState, rc, B_RBI_RCE, G_RT1_RCA, G_RT1_RCE, G_RBA_RCU, K_RT1_RCA, K_RT1_RCE, K_RBA_RCU, M_RT1_RCA, M_RT1_RCE, M_RBE_RCU, S_RDU_RCU, S_RDA_RCA, S_RDE_RCE) \
-	/* Prepare round */    \
-	MOVQ rCe, rDa;         \
-	ROLQ $1, rDa;          \
-	                       \
-	MOVQ _bi(iState), rCi; \
-	XORQ _gi(iState), rDi; \
-	XORQ rCu, rDa;         \
-	XORQ _ki(iState), rCi; \
-	XORQ _mi(iState), rDi; \
-	XORQ rDi, rCi;         \
-	                       \
-	MOVQ rCi, rDe;         \
-	ROLQ $1, rDe;          \
-	                       \
-	MOVQ _bo(iState), rCo; \
-	XORQ _go(iState), rDo; \
-	XORQ rCa, rDe;         \
-	XORQ _ko(iState), rCo; \
-	XORQ _mo(iState), rDo; \
-	XORQ rDo, rCo;         \
-	                       \
-	MOVQ rCo, rDi;         \
-	ROLQ $1, rDi;          \
-	                       \
-	MOVQ rCu, rDo;         \
-	XORQ rCe, rDi;         \
-	ROLQ $1, rDo;          \
-	                       \
-	MOVQ rCa, rDu;         \
-	XORQ rCi, rDo;         \
-	ROLQ $1, rDu;          \
-	                       \
-	/* Result b */         \
-	MOVQ _ba(iState), rBa; \
-	MOVQ _ge(iState), rBe; \
-	XORQ rCo, rDu;         \
-	MOVQ _ki(iState), rBi; \
-	MOVQ _mo(iState), rBo; \
-	MOVQ _su(iState), rBu; \
-	XORQ rDe, rBe;         \
-	ROLQ $44, rBe;         \
-	XORQ rDi, rBi;         \
-	XORQ rDa, rBa;         \
-	ROLQ $43, rBi;         \
-	                       \
-	MOVQ rBe, rCa;         \
-	MOVQ rc, rT1;          \
-	ORQ  rBi, rCa;         \
-	XORQ rBa, rT1;         \
-	XORQ rT1, rCa;         \
-	MOVQ rCa, _ba(oState); \
-	                       \
-	XORQ rDu, rBu;         \
-	ROLQ $14, rBu;         \
-	MOVQ rBa, rCu;         \
-	ANDQ rBe, rCu;         \
-	XORQ rBu, rCu;         \
-	MOVQ rCu, _bu(oState); \
-	                       \
-	XORQ rDo, rBo;         \
-	ROLQ $21, rBo;         \
-	MOVQ rBo, rT1;         \
-	ANDQ rBu, rT1;         \
-	XORQ rBi, rT1;         \
-	MOVQ rT1, _bi(oState); \
-	                       \
-	NOTQ rBi;              \
-	ORQ  rBa, rBu;         \
-	ORQ  rBo, rBi;         \
-	XORQ rBo, rBu;         \
-	XORQ rBe, rBi;         \
-	MOVQ rBu, _bo(oState); \
-	MOVQ rBi, _be(oState); \
-	B_RBI_RCE;             \
-	                       \
-	/* Result g */         \
-	MOVQ _gu(iState), rBe; \
-	XORQ rDu, rBe;         \
-	MOVQ _ka(iState), rBi; \
-	ROLQ $20, rBe;         \
-	XORQ rDa, rBi;         \
-	ROLQ $3, rBi;          \
-	MOVQ _bo(iState), rBa; \
-	MOVQ rBe, rT1;         \
-	ORQ  rBi, rT1;         \
-	XORQ rDo, rBa;         \
-	MOVQ _me(iState), rBo; \
-	MOVQ _si(iState), rBu; \
-	ROLQ $28, rBa;         \
-	XORQ rBa, rT1;         \
-	MOVQ rT1, _ga(oState); \
-	G_RT1_RCA;             \
-	                       \
-	XORQ rDe, rBo;         \
-	ROLQ $45, rBo;         \
-	MOVQ rBi, rT1;         \
-	ANDQ rBo, rT1;         \
-	XORQ rBe, rT1;         \
-	MOVQ rT1, _ge(oState); \
-	G_RT1_RCE;             \
-	                       \
-	XORQ rDi, rBu;         \
-	ROLQ $61, rBu;         \
-	MOVQ rBu, rT1;         \
-	ORQ  rBa, rT1;         \
-	XORQ rBo, rT1;         \
-	MOVQ rT1, _go(oState); \
-	                       \
-	ANDQ rBe, rBa;         \
-	XORQ rBu, rBa;         \
-	MOVQ rBa, _gu(oState); \
-	NOTQ rBu;              \
-	G_RBA_RCU;             \
-	                       \
-	ORQ  rBu, rBo;         \
-	XORQ rBi, rBo;         \
-	MOVQ rBo, _gi(oState); \
-	                       \
-	/* Result k */         \
-	MOVQ _be(iState), rBa; \
-	MOVQ _gi(iState), rBe; \
-	MOVQ _ko(iState), rBi; \
-	MOVQ _mu(iState), rBo; \
-	MOVQ _sa(iState), rBu; \
-	XORQ rDi, rBe;         \
-	ROLQ $6, rBe;          \
-	XORQ rDo, rBi;         \
-	ROLQ $25, rBi;         \
-	MOVQ rBe, rT1;         \
-	ORQ  rBi, rT1;         \
-	XORQ rDe, rBa;         \
-	ROLQ $1, rBa;          \
-	XORQ rBa, rT1;         \
-	MOVQ rT1, _ka(oState); \
-	K_RT1_RCA;             \
-	                       \
-	XORQ rDu, rBo;         \
-	ROLQ $8, rBo;          \
-	MOVQ rBi, rT1;         \
-	ANDQ rBo, rT1;         \
-	XORQ rBe, rT1;         \
-	MOVQ rT1, _ke(oState); \
-	K_RT1_RCE;             \
-	                       \
-	XORQ rDa, rBu;         \
-	ROLQ $18, rBu;         \
-	NOTQ rBo;              \
-	MOVQ rBo, rT1;         \
-	ANDQ rBu, rT1;         \
-	XORQ rBi, rT1;         \
-	MOVQ rT1, _ki(oState); \
-	                       \
-	MOVQ rBu, rT1;         \
-	ORQ  rBa, rT1;         \
-	XORQ rBo, rT1;         \
-	MOVQ rT1, _ko(oState); \
-	                       \
-	ANDQ rBe, rBa;         \
-	XORQ rBu, rBa;         \
-	MOVQ rBa, _ku(oState); \
-	K_RBA_RCU;             \
-	                       \
-	/* Result m */         \
-	MOVQ _ga(iState), rBe; \
-	XORQ rDa, rBe;         \
-	MOVQ _ke(iState), rBi; \
-	ROLQ $36, rBe;         \
-	XORQ rDe, rBi;         \
-	MOVQ _bu(iState), rBa; \
-	ROLQ $10, rBi;         \
-	MOVQ rBe, rT1;         \
-	MOVQ _mi(iState), rBo; \
-	ANDQ rBi, rT1;         \
-	XORQ rDu, rBa;         \
-	MOVQ _so(iState), rBu; \
-	ROLQ $27, rBa;         \
-	XORQ rBa, rT1;         \
-	MOVQ rT1, _ma(oState); \
-	M_RT1_RCA;             \
-	                       \
-	XORQ rDi, rBo;         \
-	ROLQ $15, rBo;         \
-	MOVQ rBi, rT1;         \
-	ORQ  rBo, rT1;         \
-	XORQ rBe, rT1;         \
-	MOVQ rT1, _me(oState); \
-	M_RT1_RCE;             \
-	                       \
-	XORQ rDo, rBu;         \
-	ROLQ $56, rBu;         \
-	NOTQ rBo;              \
-	MOVQ rBo, rT1;         \
-	ORQ  rBu, rT1;         \
-	XORQ rBi, rT1;         \
-	MOVQ rT1, _mi(oState); \
-	                       \
-	ORQ  rBa, rBe;         \
-	XORQ rBu, rBe;         \
-	MOVQ rBe, _mu(oState); \
-	                       \
-	ANDQ rBa, rBu;         \
-	XORQ rBo, rBu;         \
-	MOVQ rBu, _mo(oState); \
-	M_RBE_RCU;             \
-	                       \
-	/* Result s */         \
-	MOVQ _bi(iState), rBa; \
-	MOVQ _go(iState), rBe; \
-	MOVQ _ku(iState), rBi; \
-	XORQ rDi, rBa;         \
-	MOVQ _ma(iState), rBo; \
-	ROLQ $62, rBa;         \
-	XORQ rDo, rBe;         \
-	MOVQ _se(iState), rBu; \
-	ROLQ $55, rBe;         \
-	                       \
-	XORQ rDu, rBi;         \
-	MOVQ rBa, rDu;         \
-	XORQ rDe, rBu;         \
-	ROLQ $2, rBu;          \
-	ANDQ rBe, rDu;         \
-	XORQ rBu, rDu;         \
-	MOVQ rDu, _su(oState); \
-	                       \
-	ROLQ $39, rBi;         \
-	S_RDU_RCU;             \
-	NOTQ rBe;              \
-	XORQ rDa, rBo;         \
-	MOVQ rBe, rDa;         \
-	ANDQ rBi, rDa;         \
-	XORQ rBa, rDa;         \
-	MOVQ rDa, _sa(oState); \
-	S_RDA_RCA;             \
-	                       \
-	ROLQ $41, rBo;         \
-	MOVQ rBi, rDe;         \
-	ORQ  rBo, rDe;         \
-	XORQ rBe, rDe;         \
-	MOVQ rDe, _se(oState); \
-	S_RDE_RCE;             \
-	                       \
-	MOVQ rBo, rDi;         \
-	MOVQ rBu, rDo;         \
-	ANDQ rBu, rDi;         \
-	ORQ  rBa, rDo;         \
-	XORQ rBi, rDi;         \
-	XORQ rBo, rDo;         \
-	MOVQ rDi, _si(oState); \
-	MOVQ rDo, _so(oState)  \
-
-// func keccakF1600(state *[25]uint64)
-TEXT ·keccakF1600(SB), 0, $200-8
-	MOVQ state+0(FP), rpState
-	SUBQ $(8*25), SP
-
-	// Convert the user state into an internal state
-	NOTQ _be(rpState)
-	NOTQ _bi(rpState)
-	NOTQ _go(rpState)
-	NOTQ _ki(rpState)
-	NOTQ _mi(rpState)
-	NOTQ _sa(rpState)
-
-	// Execute the KeccakF permutation
-	MOVQ _ba(rpState), rCa
-	MOVQ _be(rpState), rCe
-	MOVQ _bu(rpState), rCu
-
-	XORQ _ga(rpState), rCa
-	XORQ _ge(rpState), rCe
-	XORQ _gu(rpState), rCu
-
-	XORQ _ka(rpState), rCa
-	XORQ _ke(rpState), rCe
-	XORQ _ku(rpState), rCu
-
-	XORQ _ma(rpState), rCa
-	XORQ _me(rpState), rCe
-	XORQ _mu(rpState), rCu
-
-	XORQ _sa(rpState), rCa
-	XORQ _se(rpState), rCe
-	MOVQ _si(rpState), rDi
-	MOVQ _so(rpState), rDo
-	XORQ _su(rpState), rCu
-
-	mKeccakRound(rpState, rpStack, $0x0000000000000001, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpStack, rpState, $0x0000000000008082, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpState, rpStack, $0x800000000000808a, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpStack, rpState, $0x8000000080008000, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpState, rpStack, $0x000000000000808b, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpStack, rpState, $0x0000000080000001, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpState, rpStack, $0x8000000080008081, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpStack, rpState, $0x8000000000008009, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpState, rpStack, $0x000000000000008a, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpStack, rpState, $0x0000000000000088, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpState, rpStack, $0x0000000080008009, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpStack, rpState, $0x000000008000000a, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpState, rpStack, $0x000000008000808b, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpStack, rpState, $0x800000000000008b, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpState, rpStack, $0x8000000000008089, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpStack, rpState, $0x8000000000008003, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpState, rpStack, $0x8000000000008002, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpStack, rpState, $0x8000000000000080, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpState, rpStack, $0x000000000000800a, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpStack, rpState, $0x800000008000000a, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpState, rpStack, $0x8000000080008081, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpStack, rpState, $0x8000000000008080, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpState, rpStack, $0x0000000080000001, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
-	mKeccakRound(rpStack, rpState, $0x8000000080008008, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP)
-
-	// Revert the internal state to the user state
-	NOTQ _be(rpState)
-	NOTQ _bi(rpState)
-	NOTQ _go(rpState)
-	NOTQ _ki(rpState)
-	NOTQ _mi(rpState)
-	NOTQ _sa(rpState)
-
-	ADDQ $(8*25), SP
-	RET

crypto/sha3/sha3.go

@@ -42,7 +42,7 @@ type state struct {
 	storage [maxRate]byte
 
 	// Specific to SHA-3 and SHAKE.
-	fixedOutput bool            // whether this is a fixed-output-length instance
+	fixedOutput bool            // whether this is a fixed-ouput-length instance
 	outputLen   int             // the default output size in bytes
 	state       spongeDirection // whether the sponge is absorbing or squeezing
 }

crypto/sha3/xor.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !amd64,!386,!ppc64le appengine
+// +build !amd64,!386 appengine
 
 package sha3
 

crypto/sha3/xor_unaligned.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build amd64 386 ppc64le
+// +build amd64 386
 // +build !appengine
 
 package sha3

eth/api.go

@@ -46,7 +46,6 @@ import (
 	"github.com/ethereum/go-ethereum/logger/glog"
 	"github.com/ethereum/go-ethereum/miner"
 	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/syndtr/goleveldb/leveldb"
@@ -325,18 +324,22 @@ func (s *PublicTxPoolAPI) Content() map[string]map[string]map[string][]*RPCTrans
 	// Flatten the pending transactions
 	for account, batches := range pending {
 		dump := make(map[string][]*RPCTransaction)
-		for _, tx := range batches {
-			nonce := fmt.Sprintf("%d", tx.Nonce())
-			dump[nonce] = []*RPCTransaction{newRPCPendingTransaction(tx)}
+		for nonce, txs := range batches {
+			nonce := fmt.Sprintf("%d", nonce)
+			for _, tx := range txs {
+				dump[nonce] = append(dump[nonce], newRPCPendingTransaction(tx))
+			}
 		}
 		content["pending"][account.Hex()] = dump
 	}
 	// Flatten the queued transactions
 	for account, batches := range queue {
 		dump := make(map[string][]*RPCTransaction)
-		for _, tx := range batches {
-			nonce := fmt.Sprintf("%d", tx.Nonce())
-			dump[nonce] = []*RPCTransaction{newRPCPendingTransaction(tx)}
+		for nonce, txs := range batches {
+			nonce := fmt.Sprintf("%d", nonce)
+			for _, tx := range txs {
+				dump[nonce] = append(dump[nonce], newRPCPendingTransaction(tx))
+			}
 		}
 		content["queued"][account.Hex()] = dump
 	}
@@ -371,18 +374,22 @@ func (s *PublicTxPoolAPI) Inspect() map[string]map[string]map[string][]string {
 	// Flatten the pending transactions
 	for account, batches := range pending {
 		dump := make(map[string][]string)
-		for _, tx := range batches {
-			nonce := fmt.Sprintf("%d", tx.Nonce())
-			dump[nonce] = []string{format(tx)}
+		for nonce, txs := range batches {
+			nonce := fmt.Sprintf("%d", nonce)
+			for _, tx := range txs {
+				dump[nonce] = append(dump[nonce], format(tx))
+			}
 		}
 		content["pending"][account.Hex()] = dump
 	}
 	// Flatten the queued transactions
 	for account, batches := range queue {
 		dump := make(map[string][]string)
-		for _, tx := range batches {
-			nonce := fmt.Sprintf("%d", tx.Nonce())
-			dump[nonce] = []string{format(tx)}
+		for nonce, txs := range batches {
+			nonce := fmt.Sprintf("%d", nonce)
+			for _, tx := range txs {
+				dump[nonce] = append(dump[nonce], format(tx))
+			}
 		}
 		content["queued"][account.Hex()] = dump
 	}
@@ -409,7 +416,6 @@ func (s *PublicAccountAPI) Accounts() []accounts.Account {
 // It offers methods to create, (un)lock en list accounts. Some methods accept
 // passwords and are therefore considered private by default.
 type PrivateAccountAPI struct {
-	bc     *core.BlockChain
 	am     *accounts.Manager
 	txPool *core.TxPool
 	txMu   *sync.Mutex
@@ -419,7 +425,6 @@ type PrivateAccountAPI struct {
 // NewPrivateAccountAPI create a new PrivateAccountAPI.
 func NewPrivateAccountAPI(e *Ethereum) *PrivateAccountAPI {
 	return &PrivateAccountAPI{
-		bc:     e.blockchain,
 		am:     e.accountManager,
 		txPool: e.txPool,
 		txMu:   &e.txMu,
@@ -498,10 +503,6 @@ func (s *PrivateAccountAPI) SignAndSendTransaction(args SendTxArgs, passwd strin
 		tx = types.NewTransaction(args.Nonce.Uint64(), *args.To, args.Value.BigInt(), args.Gas.BigInt(), args.GasPrice.BigInt(), common.FromHex(args.Data))
 	}
 
-	if s.bc.Config().IsEIP155(s.bc.CurrentBlock().Number()) {
-		tx.SetSigner(types.NewEIP155Signer(s.bc.Config().ChainId))
-	}
-
 	signature, err := s.am.SignWithPassphrase(args.From, passwd, tx.SigHash().Bytes())
 	if err != nil {
 		return common.Hash{}, err
@@ -513,7 +514,7 @@ func (s *PrivateAccountAPI) SignAndSendTransaction(args SendTxArgs, passwd strin
 // PublicBlockChainAPI provides an API to access the Ethereum blockchain.
 // It offers only methods that operate on public data that is freely available to anyone.
 type PublicBlockChainAPI struct {
-	config                  *params.ChainConfig
+	config                  *core.ChainConfig
 	bc                      *core.BlockChain
 	chainDb                 ethdb.Database
 	eventMux                *event.TypeMux
@@ -525,7 +526,7 @@ type PublicBlockChainAPI struct {
 }
 
 // NewPublicBlockChainAPI creates a new Etheruem blockchain API.
-func NewPublicBlockChainAPI(config *params.ChainConfig, bc *core.BlockChain, m *miner.Miner, chainDb ethdb.Database, gpo *GasPriceOracle, eventMux *event.TypeMux, am *accounts.Manager) *PublicBlockChainAPI {
+func NewPublicBlockChainAPI(config *core.ChainConfig, bc *core.BlockChain, m *miner.Miner, chainDb ethdb.Database, gpo *GasPriceOracle, eventMux *event.TypeMux, am *accounts.Manager) *PublicBlockChainAPI {
 	api := &PublicBlockChainAPI{
 		config:   config,
 		bc:       bc,
@@ -776,7 +777,7 @@ func (s *PublicBlockChainAPI) doCall(args CallArgs, blockNr rpc.BlockNumber) (st
 	}
 
 	// Execute the call and return
-	vmenv := core.NewEnv(stateDb, s.config, s.bc, msg, block.Header(), vm.Config{})
+	vmenv := core.NewEnv(stateDb, s.config, s.bc, msg, block.Header(), s.config.VmConfig)
 	gp := new(core.GasPool).AddGas(common.MaxBig)
 
 	res, requiredGas, _, err := core.NewStateTransition(vmenv, msg, gp).TransitionDb()
@@ -830,9 +831,6 @@ func (s *PublicBlockChainAPI) rpcOutputBlock(b *types.Block, inclTx bool, fullTx
 
 		if fullTx {
 			formatTx = func(tx *types.Transaction) (interface{}, error) {
-				if tx.Protected() {
-					tx.SetSigner(types.NewEIP155Signer(s.bc.Config().ChainId))
-				}
 				return newRPCTransaction(b, tx.Hash())
 			}
 		}
@@ -989,7 +987,7 @@ func getTransaction(chainDb ethdb.Database, txPool *core.TxPool, txHash common.H
 		}
 	} else {
 		// pending transaction?
-		tx = txPool.Get(txHash)
+		tx = txPool.GetTransaction(txHash)
 		isPending = true
 	}
 
@@ -1217,10 +1215,6 @@ func (s *PublicTransactionPoolAPI) SendTransaction(args SendTxArgs) (common.Hash
 		tx = types.NewTransaction(args.Nonce.Uint64(), *args.To, args.Value.BigInt(), args.Gas.BigInt(), args.GasPrice.BigInt(), common.FromHex(args.Data))
 	}
 
-	if s.bc.Config().IsEIP155(s.bc.CurrentBlock().Number()) {
-		tx.SetSigner(types.NewEIP155Signer(s.bc.Config().ChainId))
-	}
-
 	signature, err := s.am.Sign(args.From, tx.SigHash().Bytes())
 	if err != nil {
 		return common.Hash{}, err
@@ -1405,13 +1399,12 @@ func (s *PublicTransactionPoolAPI) SignTransaction(args SignTransactionArgs) (*S
 // PendingTransactions returns the transactions that are in the transaction pool and have a from address that is one of
 // the accounts this node manages.
 func (s *PublicTransactionPoolAPI) PendingTransactions() []*RPCTransaction {
-	pending := s.txPool.Pending()
+	pending := s.txPool.GetTransactions()
 	transactions := make([]*RPCTransaction, 0, len(pending))
-	for addr, txs := range pending {
-		if s.am.HasAddress(addr) {
-			for _, tx := range txs {
-				transactions = append(transactions, newRPCPendingTransaction(tx))
-			}
+	for _, tx := range pending {
+		from, _ := tx.FromFrontier()
+		if s.am.HasAddress(from) {
+			transactions = append(transactions, newRPCPendingTransaction(tx))
 		}
 	}
 	return transactions
@@ -1445,36 +1438,35 @@ func (s *PublicTransactionPoolAPI) NewPendingTransactions(ctx context.Context) (
 // Resend accepts an existing transaction and a new gas price and limit. It will remove the given transaction from the
 // pool and reinsert it with the new gas price and limit.
 func (s *PublicTransactionPoolAPI) Resend(tx Tx, gasPrice, gasLimit *rpc.HexNumber) (common.Hash, error) {
-	pending := s.txPool.Pending()
-	for addr, txs := range pending {
-		for _, p := range txs {
-			if addr == tx.From && p.SigHash() == tx.tx.SigHash() {
-				if gasPrice == nil {
-					gasPrice = rpc.NewHexNumber(tx.tx.GasPrice())
-				}
-				if gasLimit == nil {
-					gasLimit = rpc.NewHexNumber(tx.tx.Gas())
-				}
 
-				var newTx *types.Transaction
-				if tx.tx.To() == nil {
-					newTx = types.NewContractCreation(tx.tx.Nonce(), tx.tx.Value(), gasPrice.BigInt(), gasLimit.BigInt(), tx.tx.Data())
-				} else {
-					newTx = types.NewTransaction(tx.tx.Nonce(), *tx.tx.To(), tx.tx.Value(), gasPrice.BigInt(), gasLimit.BigInt(), tx.tx.Data())
-				}
-
-				signedTx, err := s.sign(tx.From, newTx)
-				if err != nil {
-					return common.Hash{}, err
-				}
-
-				s.txPool.Remove(tx.Hash)
-				if err = s.txPool.Add(signedTx); err != nil {
-					return common.Hash{}, err
-				}
-
-				return signedTx.Hash(), nil
+	pending := s.txPool.GetTransactions()
+	for _, p := range pending {
+		if pFrom, err := p.FromFrontier(); err == nil && pFrom == tx.From && p.SigHash() == tx.tx.SigHash() {
+			if gasPrice == nil {
+				gasPrice = rpc.NewHexNumber(tx.tx.GasPrice())
 			}
+			if gasLimit == nil {
+				gasLimit = rpc.NewHexNumber(tx.tx.Gas())
+			}
+
+			var newTx *types.Transaction
+			if tx.tx.To() == nil {
+				newTx = types.NewContractCreation(tx.tx.Nonce(), tx.tx.Value(), gasPrice.BigInt(), gasLimit.BigInt(), tx.tx.Data())
+			} else {
+				newTx = types.NewTransaction(tx.tx.Nonce(), *tx.tx.To(), tx.tx.Value(), gasPrice.BigInt(), gasLimit.BigInt(), tx.tx.Data())
+			}
+
+			signedTx, err := s.sign(tx.From, newTx)
+			if err != nil {
+				return common.Hash{}, err
+			}
+
+			s.txPool.RemoveTx(tx.Hash)
+			if err = s.txPool.Add(signedTx); err != nil {
+				return common.Hash{}, err
+			}
+
+			return signedTx.Hash(), nil
 		}
 	}
 
@@ -1583,14 +1575,14 @@ func NewPublicDebugAPI(eth *Ethereum) *PublicDebugAPI {
 }
 
 // DumpBlock retrieves the entire state of the database at a given block.
-func (api *PublicDebugAPI) DumpBlock(number uint64) (state.Dump, error) {
+func (api *PublicDebugAPI) DumpBlock(number uint64) (state.World, error) {
 	block := api.eth.BlockChain().GetBlockByNumber(number)
 	if block == nil {
-		return state.Dump{}, fmt.Errorf("block #%d not found", number)
+		return state.World{}, fmt.Errorf("block #%d not found", number)
 	}
-	stateDb, err := api.eth.BlockChain().StateAt(block.Root())
+	stateDb, err := state.New(block.Root(), api.eth.ChainDb())
 	if err != nil {
-		return state.Dump{}, err
+		return state.World{}, err
 	}
 	return stateDb.RawDump(), nil
 }
@@ -1633,13 +1625,13 @@ func (api *PublicDebugAPI) SeedHash(number uint64) (string, error) {
 // PrivateDebugAPI is the collection of Etheruem APIs exposed over the private
 // debugging endpoint.
 type PrivateDebugAPI struct {
-	config *params.ChainConfig
+	config *core.ChainConfig
 	eth    *Ethereum
 }
 
 // NewPrivateDebugAPI creates a new API definition for the private debug methods
 // of the Ethereum service.
-func NewPrivateDebugAPI(config *params.ChainConfig, eth *Ethereum) *PrivateDebugAPI {
+func NewPrivateDebugAPI(config *core.ChainConfig, eth *Ethereum) *PrivateDebugAPI {
 	return &PrivateDebugAPI{config: config, eth: eth}
 }
 
@@ -1756,7 +1748,7 @@ func (api *PrivateDebugAPI) traceBlock(block *types.Block, config *vm.Config) (b
 	if err := core.ValidateHeader(api.config, blockchain.AuxValidator(), block.Header(), blockchain.GetHeader(block.ParentHash()), true, false); err != nil {
 		return false, collector.traces, err
 	}
-	statedb, err := blockchain.StateAt(blockchain.GetBlock(block.ParentHash()).Root())
+	statedb, err := state.New(blockchain.GetBlock(block.ParentHash()).Root(), api.eth.ChainDb())
 	if err != nil {
 		return false, collector.traces, err
 	}
@@ -1858,7 +1850,7 @@ func (api *PrivateDebugAPI) TraceTransaction(txHash common.Hash, logger *vm.LogC
 	if parent == nil {
 		return nil, fmt.Errorf("block parent %x not found", block.ParentHash())
 	}
-	stateDb, err := api.eth.BlockChain().StateAt(parent.Root())
+	stateDb, err := state.New(parent.Root(), api.eth.ChainDb())
 	if err != nil {
 		return nil, err
 	}