Merge remote-tracking branch 'upstream/develop' into limits-changes

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

Makefile

@@ -2,7 +2,7 @@
 # with Go source code. If you know what GOPATH is then you probably
 # don't need to bother with make.
 
-.PHONY: geth mist all test travis-test-with-coverage clean
+.PHONY: geth evm mist all test travis-test-with-coverage clean
 GOBIN = build/bin
 
 geth:
@@ -10,6 +10,10 @@ geth:
 	@echo "Done building."
 	@echo "Run \"$(GOBIN)/geth\" to launch geth."
 
+evm:
+	build/env.sh $(GOROOT)/bin/go install -v $(shell build/ldflags.sh) ./cmd/evm
+	@echo "Done building."
+	@echo "Run \"$(GOBIN)/evm to start the evm."
 mist:
 	build/env.sh go install -v $(shell build/ldflags.sh) ./cmd/mist
 	@echo "Done building."

cmd/ethtest/main.go

@@ -26,6 +26,7 @@ import (
 	"strings"
 
 	"github.com/codegangsta/cli"
+	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/logger/glog"
 	"github.com/ethereum/go-ethereum/tests"
 )
@@ -62,6 +63,10 @@ var (
 		Name:  "skip",
 		Usage: "Tests names to skip",
 	}
+	TraceFlag = cli.BoolFlag{
+		Name:  "trace",
+		Usage: "Enable VM tracing",
+	}
 )
 
 func runTestWithReader(test string, r io.Reader) error {
@@ -173,7 +178,6 @@ func runSuite(test, file string) {
 					glog.Fatalln(err)
 				}
 			}
-
 		}
 	}
 }
@@ -184,6 +188,7 @@ func setupApp(c *cli.Context) {
 	continueOnError = c.GlobalBool(ContinueOnErrorFlag.Name)
 	useStdIn := c.GlobalBool(ReadStdInFlag.Name)
 	skipTests = strings.Split(c.GlobalString(SkipTestsFlag.Name), " ")
+	vm.Debug = c.GlobalBool(TraceFlag.Name)
 
 	if !useStdIn {
 		runSuite(flagTest, flagFile)
@@ -211,6 +216,7 @@ func main() {
 		ContinueOnErrorFlag,
 		ReadStdInFlag,
 		SkipTestsFlag,
+		TraceFlag,
 	}
 
 	if err := app.Run(os.Args); err != nil {

cmd/evm/main.go

@@ -32,6 +32,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/logger/glog"
 )
 
 var (
@@ -40,6 +41,14 @@ var (
 		Name:  "debug",
 		Usage: "output full trace logs",
 	}
+	ForceJitFlag = cli.BoolFlag{
+		Name:  "forcejit",
+		Usage: "forces jit compilation",
+	}
+	DisableJitFlag = cli.BoolFlag{
+		Name:  "nojit",
+		Usage: "disabled jit compilation",
+	}
 	CodeFlag = cli.StringFlag{
 		Name:  "code",
 		Usage: "EVM code",
@@ -77,6 +86,8 @@ func init() {
 	app = utils.NewApp("0.2", "the evm command line interface")
 	app.Flags = []cli.Flag{
 		DebugFlag,
+		ForceJitFlag,
+		DisableJitFlag,
 		SysStatFlag,
 		CodeFlag,
 		GasFlag,
@@ -90,6 +101,10 @@ func init() {
 
 func run(ctx *cli.Context) {
 	vm.Debug = ctx.GlobalBool(DebugFlag.Name)
+	vm.ForceJit = ctx.GlobalBool(ForceJitFlag.Name)
+	vm.DisableJit = ctx.GlobalBool(DisableJitFlag.Name)
+
+	glog.SetToStderr(true)
 
 	db, _ := ethdb.NewMemDatabase()
 	statedb := state.New(common.Hash{}, db)
@@ -110,11 +125,6 @@ func run(ctx *cli.Context) {
 	)
 	vmdone := time.Since(tstart)
 
-	if e != nil {
-		fmt.Println(e)
-		os.Exit(1)
-	}
-
 	if ctx.GlobalBool(DumpFlag.Name) {
 		fmt.Println(string(statedb.Dump()))
 	}
@@ -133,7 +143,11 @@ num gc:     %d
 `, mem.Alloc, mem.TotalAlloc, mem.Mallocs, mem.HeapAlloc, mem.HeapObjects, mem.NumGC)
 	}
 
-	fmt.Printf("OUT: 0x%x\n", ret)
+	fmt.Printf("OUT: 0x%x", ret)
+	if e != nil {
+		fmt.Printf(" error: %v", e)
+	}
+	fmt.Println()
 }
 
 func main() {
@@ -192,6 +206,9 @@ func (self *VMEnv) StructLogs() []vm.StructLog {
 func (self *VMEnv) AddLog(log *state.Log) {
 	self.state.AddLog(log)
 }
+func (self *VMEnv) CanTransfer(from vm.Account, balance *big.Int) bool {
+	return from.Balance().Cmp(balance) >= 0
+}
 func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error {
 	return vm.Transfer(from, to, amount)
 }

cmd/geth/chaincmd.go

@@ -74,10 +74,10 @@ func importChain(ctx *cli.Context) {
 	if len(ctx.Args()) != 1 {
 		utils.Fatalf("This command requires an argument.")
 	}
-	chain, blockDB, stateDB, extraDB := utils.MakeChain(ctx)
+	chain, chainDb := utils.MakeChain(ctx)
 	start := time.Now()
 	err := utils.ImportChain(chain, ctx.Args().First())
-	closeAll(blockDB, stateDB, extraDB)
+	chainDb.Close()
 	if err != nil {
 		utils.Fatalf("Import error: %v", err)
 	}
@@ -88,7 +88,7 @@ func exportChain(ctx *cli.Context) {
 	if len(ctx.Args()) < 1 {
 		utils.Fatalf("This command requires an argument.")
 	}
-	chain, _, _, _ := utils.MakeChain(ctx)
+	chain, _ := utils.MakeChain(ctx)
 	start := time.Now()
 
 	var err error
@@ -136,8 +136,8 @@ func removeDB(ctx *cli.Context) {
 func upgradeDB(ctx *cli.Context) {
 	glog.Infoln("Upgrading blockchain database")
 
-	chain, blockDB, stateDB, extraDB := utils.MakeChain(ctx)
+	chain, chainDb := utils.MakeChain(ctx)
-	v, _ := blockDB.Get([]byte("BlockchainVersion"))
+	v, _ := chainDb.Get([]byte("BlockchainVersion"))
 	bcVersion := int(common.NewValue(v).Uint())
 	if bcVersion == 0 {
 		bcVersion = core.BlockChainVersion
@@ -149,15 +149,14 @@ func upgradeDB(ctx *cli.Context) {
 	if err := utils.ExportChain(chain, exportFile); err != nil {
 		utils.Fatalf("Unable to export chain for reimport %s", err)
 	}
-	closeAll(blockDB, stateDB, extraDB)
+	chainDb.Close()
-	os.RemoveAll(filepath.Join(ctx.GlobalString(utils.DataDirFlag.Name), "blockchain"))
+	os.RemoveAll(filepath.Join(ctx.GlobalString(utils.DataDirFlag.Name), "chaindata"))
-	os.RemoveAll(filepath.Join(ctx.GlobalString(utils.DataDirFlag.Name), "state"))
 
 	// Import the chain file.
-	chain, blockDB, stateDB, extraDB = utils.MakeChain(ctx)
+	chain, chainDb = utils.MakeChain(ctx)
-	blockDB.Put([]byte("BlockchainVersion"), common.NewValue(core.BlockChainVersion).Bytes())
+	chainDb.Put([]byte("BlockchainVersion"), common.NewValue(core.BlockChainVersion).Bytes())
 	err := utils.ImportChain(chain, exportFile)
-	closeAll(blockDB, stateDB, extraDB)
+	chainDb.Close()
 	if err != nil {
 		utils.Fatalf("Import error %v (a backup is made in %s, use the import command to import it)", err, exportFile)
 	} else {
@@ -167,7 +166,7 @@ func upgradeDB(ctx *cli.Context) {
 }
 
 func dump(ctx *cli.Context) {
-	chain, _, stateDB, _ := utils.MakeChain(ctx)
+	chain, chainDb := utils.MakeChain(ctx)
 	for _, arg := range ctx.Args() {
 		var block *types.Block
 		if hashish(arg) {
@@ -180,10 +179,11 @@ func dump(ctx *cli.Context) {
 			fmt.Println("{}")
 			utils.Fatalf("block not found")
 		} else {
-			state := state.New(block.Root(), stateDB)
+			state := state.New(block.Root(), chainDb)
 			fmt.Printf("%s\n", state.Dump())
 		}
 	}
+	chainDb.Close()
 }
 
 // hashish returns true for strings that look like hashes.

cmd/geth/main.go

@@ -42,6 +42,8 @@ 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/rlp"
 	"github.com/ethereum/go-ethereum/rpc/codec"
 	"github.com/ethereum/go-ethereum/rpc/comms"
 	"github.com/mattn/go-colorable"
@@ -49,12 +51,15 @@ import (
 )
 
 const (
-	ClientIdentifier = "Geth"
+	ClientIdentifier = "Geth                                                                                                   "
 	Version          = "1.0.1"
+	VersionMajor     = 1
+	VersionMinor     = 0
+	VersionPatch     = 1
 )
 
 var (
-	gitCommit       string // set via linker flag
+	gitCommit       string // set via linker flagg
 	nodeNameVersion string
 	app             *cli.App
 )
@@ -307,6 +312,9 @@ JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Conso
 		utils.ExecFlag,
 		utils.WhisperEnabledFlag,
 		utils.VMDebugFlag,
+		utils.VMForceJitFlag,
+		utils.VMJitCacheFlag,
+		utils.VMEnableJitFlag,
 		utils.NetworkIdFlag,
 		utils.RPCCORSDomainFlag,
 		utils.VerbosityFlag,
@@ -328,6 +336,7 @@ JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Conso
 	}
 	app.Before = func(ctx *cli.Context) error {
 		utils.SetupLogger(ctx)
+		utils.SetupVM(ctx)
 		if ctx.GlobalBool(utils.PProfEanbledFlag.Name) {
 			utils.StartPProf(ctx)
 		}
@@ -346,6 +355,27 @@ func main() {
 	}
 }
 
+func makeDefaultExtra() []byte {
+	var clientInfo = struct {
+		Version   uint
+		Name      string
+		GoVersion string
+		Os        string
+	}{uint(VersionMajor<<16 | VersionMinor<<8 | VersionPatch), ClientIdentifier, runtime.Version(), runtime.GOOS}
+	extra, err := rlp.EncodeToBytes(clientInfo)
+	if err != nil {
+		glog.V(logger.Warn).Infoln("error setting canonical miner information:", err)
+	}
+
+	if uint64(len(extra)) > params.MaximumExtraDataSize.Uint64() {
+		glog.V(logger.Warn).Infoln("error setting canonical miner information: extra exceeds", params.MaximumExtraDataSize)
+		glog.V(logger.Debug).Infof("extra: %x\n", extra)
+		return nil
+	}
+
+	return extra
+}
+
 func run(ctx *cli.Context) {
 	utils.CheckLegalese(ctx.GlobalString(utils.DataDirFlag.Name))
 	if ctx.GlobalBool(utils.OlympicFlag.Name) {
@@ -353,6 +383,8 @@ func run(ctx *cli.Context) {
 	}
 
 	cfg := utils.MakeEthConfig(ClientIdentifier, nodeNameVersion, ctx)
+	cfg.ExtraData = makeDefaultExtra()
+
 	ethereum, err := eth.New(cfg)
 	if err != nil {
 		utils.Fatalf("%v", err)

cmd/utils/cmd.go

@@ -21,6 +21,7 @@ import (
 	"bufio"
 	"fmt"
 	"io"
+	"math"
 	"math/big"
 	"os"
 	"os/signal"
@@ -152,6 +153,7 @@ func InitOlympic() {
 	params.MaximumExtraDataSize = big.NewInt(1024)
 	NetworkIdFlag.Value = 0
 	core.BlockReward = big.NewInt(1.5e+18)
+	core.ExpDiffPeriod = big.NewInt(math.MaxInt64)
 }
 
 func FormatTransactionData(data string) []byte {

cmd/utils/customflags.go

@@ -21,7 +21,7 @@ import (
 	"fmt"
 	"os"
 	"os/user"
-	"path/filepath"
+	"path"
 	"strings"
 
 	"github.com/codegangsta/cli"
@@ -138,11 +138,8 @@ func (self *DirectoryFlag) Set(value string) {
 func expandPath(p string) string {
 	if strings.HasPrefix(p, "~/") || strings.HasPrefix(p, "~\\") {
 		if user, err := user.Current(); err == nil {
-			if err == nil {
+			p = user.HomeDir + p[1:]
-				p = strings.Replace(p, "~", user.HomeDir, 1)
 		}
 	}
-	}
+	return path.Clean(os.ExpandEnv(p))
-
-	return filepath.Clean(os.ExpandEnv(p))
 }

cmd/utils/customflags_test.go

@@ -23,18 +23,15 @@ import (
 )
 
 func TestPathExpansion(t *testing.T) {
-
 	user, _ := user.Current()
-
 	tests := map[string]string{
 		"/home/someuser/tmp": "/home/someuser/tmp",
 		"~/tmp":              user.HomeDir + "/tmp",
+		"~thisOtherUser/b/":  "~thisOtherUser/b",
 		"$DDDXXX/a/b":        "/tmp/a/b",
 		"/a/b/":              "/a/b",
 	}
-
 	os.Setenv("DDDXXX", "/tmp")
-
 	for test, expected := range tests {
 		got := expandPath(test)
 		if got != expected {

cmd/utils/flags.go

@@ -27,6 +27,7 @@ import (
 	"runtime"
 	"strconv"
 
+	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/metrics"
 
 	"github.com/codegangsta/cli"
@@ -172,6 +173,25 @@ var (
 		Value: "",
 	}
 
+	// vm flags
+	VMDebugFlag = cli.BoolFlag{
+		Name:  "vmdebug",
+		Usage: "Virtual Machine debug output",
+	}
+	VMForceJitFlag = cli.BoolFlag{
+		Name:  "forcejit",
+		Usage: "Force the JIT VM to take precedence",
+	}
+	VMJitCacheFlag = cli.IntFlag{
+		Name:  "jitcache",
+		Usage: "Amount of cached JIT VM programs",
+		Value: 64,
+	}
+	VMEnableJitFlag = cli.BoolFlag{
+		Name:  "jitvm",
+		Usage: "Enable the JIT VM",
+	}
+
 	// logging and debug settings
 	LogFileFlag = cli.StringFlag{
 		Name:  "logfile",
@@ -196,10 +216,6 @@ var (
 		Usage: "The syntax of the argument is a comma-separated list of pattern=N, where pattern is a literal file name (minus the \".go\" suffix) or \"glob\" pattern and N is a log verbosity level.",
 		Value: glog.GetVModule(),
 	}
-	VMDebugFlag = cli.BoolFlag{
-		Name:  "vmdebug",
-		Usage: "Virtual Machine debug output",
-	}
 	BacktraceAtFlag = cli.GenericFlag{
 		Name:  "backtrace_at",
 		Usage: "If set to a file and line number (e.g., \"block.go:271\") holding a logging statement, a stack trace will be logged",
@@ -434,24 +450,25 @@ func SetupLogger(ctx *cli.Context) {
 	glog.SetLogDir(ctx.GlobalString(LogFileFlag.Name))
 }
 
+// SetupVM configured the VM package's global settings
+func SetupVM(ctx *cli.Context) {
+	vm.DisableJit = !ctx.GlobalBool(VMEnableJitFlag.Name)
+	vm.ForceJit = ctx.GlobalBool(VMForceJitFlag.Name)
+	vm.SetJITCacheSize(ctx.GlobalInt(VMJitCacheFlag.Name))
+}
+
 // MakeChain creates a chain manager from set command line flags.
-func MakeChain(ctx *cli.Context) (chain *core.ChainManager, blockDB, stateDB, extraDB common.Database) {
+func MakeChain(ctx *cli.Context) (chain *core.ChainManager, chainDb common.Database) {
 	datadir := ctx.GlobalString(DataDirFlag.Name)
 	cache := ctx.GlobalInt(CacheFlag.Name)
 
 	var err error
-	if blockDB, err = ethdb.NewLDBDatabase(filepath.Join(datadir, "blockchain"), cache); err != nil {
+	if chainDb, err = ethdb.NewLDBDatabase(filepath.Join(datadir, "chaindata"), cache); err != nil {
-		Fatalf("Could not open database: %v", err)
-	}
-	if stateDB, err = ethdb.NewLDBDatabase(filepath.Join(datadir, "state"), cache); err != nil {
-		Fatalf("Could not open database: %v", err)
-	}
-	if extraDB, err = ethdb.NewLDBDatabase(filepath.Join(datadir, "extra"), cache); err != nil {
 		Fatalf("Could not open database: %v", err)
 	}
 	if ctx.GlobalBool(OlympicFlag.Name) {
 		InitOlympic()
-		_, err := core.WriteTestNetGenesisBlock(stateDB, blockDB, 42)
+		_, err := core.WriteTestNetGenesisBlock(chainDb, 42)
 		if err != nil {
 			glog.Fatalln(err)
 		}
@@ -460,14 +477,14 @@ func MakeChain(ctx *cli.Context) (chain *core.ChainManager, blockDB, stateDB, ex
 	eventMux := new(event.TypeMux)
 	pow := ethash.New()
 	//genesis := core.GenesisBlock(uint64(ctx.GlobalInt(GenesisNonceFlag.Name)), blockDB)
-	chain, err = core.NewChainManager(blockDB, stateDB, extraDB, pow, eventMux)
+	chain, err = core.NewChainManager(chainDb, pow, eventMux)
 	if err != nil {
 		Fatalf("Could not start chainmanager: %v", err)
 	}
 
-	proc := core.NewBlockProcessor(stateDB, extraDB, pow, chain, eventMux)
+	proc := core.NewBlockProcessor(chainDb, pow, chain, eventMux)
 	chain.SetProcessor(proc)
-	return chain, blockDB, stateDB, extraDB
+	return chain, chainDb
 }
 
 // MakeChain creates an account manager from set command line flags.
@@ -478,7 +495,7 @@ func MakeAccountManager(ctx *cli.Context) *accounts.Manager {
 }
 
 func IpcSocketPath(ctx *cli.Context) (ipcpath string) {
-	if common.IsWindows() {
+	if runtime.GOOS == "windows" {
 		ipcpath = common.DefaultIpcPath()
 		if ctx.GlobalIsSet(IPCPathFlag.Name) {
 			ipcpath = ctx.GlobalString(IPCPathFlag.Name)

common/compiler/solidity_test.go

@@ -20,6 +20,7 @@ import (
 	"encoding/json"
 	"io/ioutil"
 	"os"
+	"path"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -94,7 +95,7 @@ func TestSaveInfo(t *testing.T) {
 	if err != nil {
 		t.Errorf("%v", err)
 	}
-	filename := "/tmp/solctest.info.json"
+	filename := path.Join(os.TempDir(), "solctest.info.json")
 	os.Remove(filename)
 	cinfohash, err := SaveInfo(&cinfo, filename)
 	if err != nil {

common/docserver/docserver.go

@@ -38,7 +38,6 @@ func New(docRoot string) (self *DocServer) {
 		DocRoot:   docRoot,
 		schemes:   []string{"file"},
 	}
-	self.DocRoot = "/tmp/"
 	self.RegisterProtocol("file", http.NewFileTransport(http.Dir(self.DocRoot)))
 	return
 }

common/docserver/docserver_test.go

@@ -20,6 +20,7 @@ import (
 	"io/ioutil"
 	"net/http"
 	"os"
+	"path"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -27,12 +28,18 @@ import (
 )
 
 func TestGetAuthContent(t *testing.T) {
-	text := "test"
+	dir, err := ioutil.TempDir("", "docserver-test")
-	hash := common.Hash{}
+	if err != nil {
-	copy(hash[:], crypto.Sha3([]byte(text)))
+		t.Fatal("cannot create temporary directory:", err)
-	ioutil.WriteFile("/tmp/test.content", []byte(text), os.ModePerm)
+	}
+	defer os.RemoveAll(dir)
+	ds := New(dir)
 
-	ds := New("/tmp/")
+	text := "test"
+	hash := crypto.Sha3Hash([]byte(text))
+	if err := ioutil.WriteFile(path.Join(dir, "test.content"), []byte(text), os.ModePerm); err != nil {
+		t.Fatal("could not write test file", err)
+	}
 	content, err := ds.GetAuthContent("file:///test.content", hash)
 	if err != nil {
 		t.Errorf("no error expected, got %v", err)

common/path.go

@@ -115,14 +115,3 @@ func DefaultIpcPath() string {
 	}
 	return filepath.Join(DefaultDataDir(), "geth.ipc")
 }
-
-func IsWindows() bool {
-	return runtime.GOOS == "windows"
-}
-
-func WindonizePath(path string) string {
-	if string(path[0]) == "/" && IsWindows() {
-		path = path[1:]
-	}
-	return path
-}

common/path_test.go

@@ -1,52 +0,0 @@
-// Copyright 2014 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package common
-
-import (
-	"os"
-	// "testing"
-
-	checker "gopkg.in/check.v1"
-)
-
-type CommonSuite struct{}
-
-var _ = checker.Suite(&CommonSuite{})
-
-func (s *CommonSuite) TestOS(c *checker.C) {
-	expwin := (os.PathSeparator == '\\' && os.PathListSeparator == ';')
-	res := IsWindows()
-
-	if !expwin {
-		c.Assert(res, checker.Equals, expwin, checker.Commentf("IsWindows is", res, "but path is", os.PathSeparator))
-	} else {
-		c.Assert(res, checker.Not(checker.Equals), expwin, checker.Commentf("IsWindows is", res, "but path is", os.PathSeparator))
-	}
-}
-
-func (s *CommonSuite) TestWindonziePath(c *checker.C) {
-	iswindowspath := os.PathSeparator == '\\'
-	path := "/opt/eth/test/file.ext"
-	res := WindonizePath(path)
-	ressep := string(res[0])
-
-	if !iswindowspath {
-		c.Assert(ressep, checker.Equals, "/")
-	} else {
-		c.Assert(ressep, checker.Not(checker.Equals), "/")
-	}
-}

common/size_test.go

@@ -40,7 +40,7 @@ func (s *SizeSuite) TestStorageSizeString(c *checker.C) {
 	c.Assert(StorageSize(data3).String(), checker.Equals, exp3)
 }
 
-func (s *CommonSuite) TestCommon(c *checker.C) {
+func (s *SizeSuite) TestCommon(c *checker.C) {
 	ether := CurrencyToString(BigPow(10, 19))
 	finney := CurrencyToString(BigPow(10, 16))
 	szabo := CurrencyToString(BigPow(10, 13))

core/bench_test.go

@@ -168,8 +168,8 @@ func benchInsertChain(b *testing.B, disk bool, gen func(int, *BlockGen)) {
 	// Time the insertion of the new chain.
 	// State and blocks are stored in the same DB.
 	evmux := new(event.TypeMux)
-	chainman, _ := NewChainManager(db, db, db, FakePow{}, evmux)
+	chainman, _ := NewChainManager(db, FakePow{}, evmux)
-	chainman.SetProcessor(NewBlockProcessor(db, db, FakePow{}, chainman, evmux))
+	chainman.SetProcessor(NewBlockProcessor(db, FakePow{}, chainman, evmux))
 	defer chainman.Stop()
 	b.ReportAllocs()
 	b.ResetTimer()

core/block_processor.go

@@ -41,8 +41,7 @@ const (
 )
 
 type BlockProcessor struct {
-	db      common.Database
+	chainDb common.Database
-	extraDb common.Database
 	// Mutex for locking the block processor. Blocks can only be handled one at a time
 	mutex sync.Mutex
 	// Canonical block chain
@@ -57,10 +56,9 @@ type BlockProcessor struct {
 	eventMux *event.TypeMux
 }
 
-func NewBlockProcessor(db, extra common.Database, pow pow.PoW, chainManager *ChainManager, eventMux *event.TypeMux) *BlockProcessor {
+func NewBlockProcessor(db common.Database, pow pow.PoW, chainManager *ChainManager, eventMux *event.TypeMux) *BlockProcessor {
 	sm := &BlockProcessor{
-		db:       db,
+		chainDb:  db,
-		extraDb:  extra,
 		mem:      make(map[string]*big.Int),
 		Pow:      pow,
 		bc:       chainManager,
@@ -84,8 +82,6 @@ func (sm *BlockProcessor) TransitionState(statedb *state.StateDB, parent, block
 }
 
 func (self *BlockProcessor) ApplyTransaction(coinbase *state.StateObject, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *big.Int, transientProcess bool) (*types.Receipt, *big.Int, error) {
-	// If we are mining this block and validating we want to set the logs back to 0
-
 	cb := statedb.GetStateObject(coinbase.Address())
 	_, gas, err := ApplyMessage(NewEnv(statedb, self.bc, tx, header), tx, cb)
 	if err != nil {
@@ -201,7 +197,7 @@ func (sm *BlockProcessor) Process(block *types.Block) (logs state.Logs, receipts
 
 func (sm *BlockProcessor) processWithParent(block, parent *types.Block) (logs state.Logs, receipts types.Receipts, err error) {
 	// Create a new state based on the parent's root (e.g., create copy)
-	state := state.New(parent.Root(), sm.db)
+	state := state.New(parent.Root(), sm.chainDb)
 	header := block.Header()
 	uncles := block.Uncles()
 	txs := block.Transactions()
@@ -342,7 +338,7 @@ func (sm *BlockProcessor) VerifyUncles(statedb *state.StateDB, block, parent *ty
 // GetBlockReceipts returns the receipts beloniging to the block hash
 func (sm *BlockProcessor) GetBlockReceipts(bhash common.Hash) types.Receipts {
 	if block := sm.ChainManager().GetBlock(bhash); block != nil {
-		return GetBlockReceipts(sm.extraDb, block.Hash())
+		return GetBlockReceipts(sm.chainDb, block.Hash())
 	}
 
 	return nil
@@ -352,7 +348,7 @@ func (sm *BlockProcessor) GetBlockReceipts(bhash common.Hash) types.Receipts {
 // where it tries to get it from the (updated) method which gets them from the receipts or
 // the depricated way by re-processing the block.
 func (sm *BlockProcessor) GetLogs(block *types.Block) (logs state.Logs, err error) {
-	receipts := GetBlockReceipts(sm.extraDb, block.Hash())
+	receipts := GetBlockReceipts(sm.chainDb, block.Hash())
 	if len(receipts) > 0 {
 		// coalesce logs
 		for _, receipt := range receipts {
@@ -364,7 +360,7 @@ func (sm *BlockProcessor) GetLogs(block *types.Block) (logs state.Logs, err erro
 	// TODO: remove backward compatibility
 	var (
 		parent = sm.bc.GetBlock(block.ParentHash())
-		state  = state.New(parent.Root(), sm.db)
+		state  = state.New(parent.Root(), sm.chainDb)
 	)
 
 	sm.TransitionState(state, parent, block, true)

core/block_processor_test.go

@@ -33,19 +33,19 @@ func proc() (*BlockProcessor, *ChainManager) {
 	db, _ := ethdb.NewMemDatabase()
 	var mux event.TypeMux
 
-	WriteTestNetGenesisBlock(db, db, 0)
+	WriteTestNetGenesisBlock(db, 0)
-	chainMan, err := NewChainManager(db, db, db, thePow(), &mux)
+	chainMan, err := NewChainManager(db, thePow(), &mux)
 	if err != nil {
 		fmt.Println(err)
 	}
-	return NewBlockProcessor(db, db, ezp.New(), chainMan, &mux), chainMan
+	return NewBlockProcessor(db, ezp.New(), chainMan, &mux), chainMan
 }
 
 func TestNumber(t *testing.T) {
 	pow := ezp.New()
 	_, chain := proc()
 
-	statedb := state.New(chain.Genesis().Root(), chain.stateDb)
+	statedb := state.New(chain.Genesis().Root(), chain.chainDb)
 	header := makeHeader(chain.Genesis(), statedb)
 	header.Number = big.NewInt(3)
 	err := ValidateHeader(pow, header, chain.Genesis(), false)

core/chain_makers.go

@@ -184,9 +184,9 @@ func makeHeader(parent *types.Block, state *state.StateDB) *types.Header {
 func newCanonical(n int, db common.Database) (*BlockProcessor, error) {
 	evmux := &event.TypeMux{}
 
-	WriteTestNetGenesisBlock(db, db, 0)
+	WriteTestNetGenesisBlock(db, 0)
-	chainman, _ := NewChainManager(db, db, db, FakePow{}, evmux)
+	chainman, _ := NewChainManager(db, FakePow{}, evmux)
-	bman := NewBlockProcessor(db, db, FakePow{}, chainman, evmux)
+	bman := NewBlockProcessor(db, FakePow{}, chainman, evmux)
 	bman.bc.SetProcessor(bman)
 	parent := bman.bc.CurrentBlock()
 	if n == 0 {

core/chain_makers_test.go

@@ -77,8 +77,8 @@ func ExampleGenerateChain() {
 
 	// Import the chain. This runs all block validation rules.
 	evmux := &event.TypeMux{}
-	chainman, _ := NewChainManager(db, db, db, FakePow{}, evmux)
+	chainman, _ := NewChainManager(db, FakePow{}, evmux)
-	chainman.SetProcessor(NewBlockProcessor(db, db, FakePow{}, chainman, evmux))
+	chainman.SetProcessor(NewBlockProcessor(db, FakePow{}, chainman, evmux))
 	if i, err := chainman.InsertChain(chain); err != nil {
 		fmt.Printf("insert error (block %d): %v\n", i, err)
 		return

core/chain_manager.go

@@ -56,9 +56,7 @@ const (
 
 type ChainManager struct {
 	//eth          EthManager
-	blockDb      common.Database
+	chainDb      common.Database
-	stateDb      common.Database
-	extraDb      common.Database
 	processor    types.BlockProcessor
 	eventMux     *event.TypeMux
 	genesisBlock *types.Block
@@ -85,12 +83,10 @@ type ChainManager struct {
 	pow pow.PoW
 }
 
-func NewChainManager(blockDb, stateDb, extraDb common.Database, pow pow.PoW, mux *event.TypeMux) (*ChainManager, error) {
+func NewChainManager(chainDb common.Database, pow pow.PoW, mux *event.TypeMux) (*ChainManager, error) {
 	cache, _ := lru.New(blockCacheLimit)
 	bc := &ChainManager{
-		blockDb:  blockDb,
+		chainDb:  chainDb,
-		stateDb:  stateDb,
-		extraDb:  extraDb,
 		eventMux: mux,
 		quit:     make(chan struct{}),
 		cache:    cache,
@@ -103,7 +99,7 @@ func NewChainManager(blockDb, stateDb, extraDb common.Database, pow pow.PoW, mux
 		if err != nil {
 			return nil, err
 		}
-		bc.genesisBlock, err = WriteGenesisBlock(stateDb, blockDb, reader)
+		bc.genesisBlock, err = WriteGenesisBlock(chainDb, reader)
 		if err != nil {
 			return nil, err
 		}
@@ -195,15 +191,15 @@ func (self *ChainManager) SetProcessor(proc types.BlockProcessor) {
 }
 
 func (self *ChainManager) State() *state.StateDB {
-	return state.New(self.CurrentBlock().Root(), self.stateDb)
+	return state.New(self.CurrentBlock().Root(), self.chainDb)
 }
 
 func (bc *ChainManager) recover() bool {
-	data, _ := bc.blockDb.Get([]byte("checkpoint"))
+	data, _ := bc.chainDb.Get([]byte("checkpoint"))
 	if len(data) != 0 {
 		block := bc.GetBlock(common.BytesToHash(data))
 		if block != nil {
-			err := bc.blockDb.Put([]byte("LastBlock"), block.Hash().Bytes())
+			err := bc.chainDb.Put([]byte("LastBlock"), block.Hash().Bytes())
 			if err != nil {
 				glog.Fatalln("db write err:", err)
 			}
@@ -217,7 +213,7 @@ func (bc *ChainManager) recover() bool {
 }
 
 func (bc *ChainManager) setLastState() error {
-	data, _ := bc.blockDb.Get([]byte("LastBlock"))
+	data, _ := bc.chainDb.Get([]byte("LastBlock"))
 	if len(data) != 0 {
 		block := bc.GetBlock(common.BytesToHash(data))
 		if block != nil {
@@ -264,7 +260,7 @@ func (bc *ChainManager) Reset() {
 	bc.cache, _ = lru.New(blockCacheLimit)
 
 	// Prepare the genesis block
-	err := WriteBlock(bc.blockDb, bc.genesisBlock)
+	err := WriteBlock(bc.chainDb, bc.genesisBlock)
 	if err != nil {
 		glog.Fatalln("db err:", err)
 	}
@@ -277,7 +273,7 @@ func (bc *ChainManager) Reset() {
 }
 
 func (bc *ChainManager) removeBlock(block *types.Block) {
-	bc.blockDb.Delete(append(blockHashPre, block.Hash().Bytes()...))
+	bc.chainDb.Delete(append(blockHashPre, block.Hash().Bytes()...))
 }
 
 func (bc *ChainManager) ResetWithGenesisBlock(gb *types.Block) {
@@ -292,7 +288,7 @@ func (bc *ChainManager) ResetWithGenesisBlock(gb *types.Block) {
 	gb.Td = gb.Difficulty()
 	bc.genesisBlock = gb
 
-	err := WriteBlock(bc.blockDb, bc.genesisBlock)
+	err := WriteBlock(bc.chainDb, bc.genesisBlock)
 	if err != nil {
 		glog.Fatalln("db err:", err)
 	}
@@ -339,14 +335,14 @@ func (self *ChainManager) ExportN(w io.Writer, first uint64, last uint64) error
 // insert injects a block into the current chain block chain. Note, this function
 // assumes that the `mu` mutex is held!
 func (bc *ChainManager) insert(block *types.Block) {
-	err := WriteHead(bc.blockDb, block)
+	err := WriteHead(bc.chainDb, block)
 	if err != nil {
 		glog.Fatal("db write fail:", err)
 	}
 
 	bc.checkpoint++
 	if bc.checkpoint > checkpointLimit {
-		err = bc.blockDb.Put([]byte("checkpoint"), block.Hash().Bytes())
+		err = bc.chainDb.Put([]byte("checkpoint"), block.Hash().Bytes())
 		if err != nil {
 			glog.Fatal("db write fail:", err)
 		}
@@ -369,7 +365,7 @@ func (bc *ChainManager) HasBlock(hash common.Hash) bool {
 		return true
 	}
 
-	data, _ := bc.blockDb.Get(append(blockHashPre, hash[:]...))
+	data, _ := bc.chainDb.Get(append(blockHashPre, hash[:]...))
 	return len(data) != 0
 }
 
@@ -399,7 +395,7 @@ func (self *ChainManager) GetBlock(hash common.Hash) *types.Block {
 		return block.(*types.Block)
 	}
 
-	block := GetBlockByHash(self.blockDb, hash)
+	block := GetBlockByHash(self.chainDb, hash)
 	if block == nil {
 		return nil
 	}
@@ -433,7 +429,7 @@ func (self *ChainManager) GetBlocksFromHash(hash common.Hash, n int) (blocks []*
 
 // non blocking version
 func (self *ChainManager) getBlockByNumber(num uint64) *types.Block {
-	return GetBlockByNumber(self.blockDb, num)
+	return GetBlockByNumber(self.chainDb, num)
 }
 
 func (self *ChainManager) GetUnclesInChain(block *types.Block, length int) (uncles []*types.Header) {
@@ -521,7 +517,7 @@ func (self *ChainManager) WriteBlock(block *types.Block, queued bool) (status wr
 		status = SideStatTy
 	}
 
-	err = WriteBlock(self.blockDb, block)
+	err = WriteBlock(self.chainDb, block)
 	if err != nil {
 		glog.Fatalln("db err:", err)
 	}
@@ -632,15 +628,15 @@ func (self *ChainManager) InsertChain(chain types.Blocks) (int, error) {
 		switch status {
 		case CanonStatTy:
 			if glog.V(logger.Debug) {
-				glog.Infof("[%v] inserted block #%d (%d TXs %d UNCs) (%x...). Took %v\n", time.Now().UnixNano(), block.Number(), len(block.Transactions()), len(block.Uncles()), block.Hash().Bytes()[0:4], time.Since(bstart))
+				glog.Infof("[%v] inserted block #%d (%d TXs %v G %d UNCs) (%x...). Took %v\n", time.Now().UnixNano(), block.Number(), len(block.Transactions()), block.GasUsed(), len(block.Uncles()), block.Hash().Bytes()[0:4], time.Since(bstart))
 			}
 			queue[i] = ChainEvent{block, block.Hash(), logs}
 			queueEvent.canonicalCount++
 
 			// This puts transactions in a extra db for rpc
-			PutTransactions(self.extraDb, block, block.Transactions())
+			PutTransactions(self.chainDb, block, block.Transactions())
 			// store the receipts
-			PutReceipts(self.extraDb, receipts)
+			PutReceipts(self.chainDb, receipts)
 		case SideStatTy:
 			if glog.V(logger.Detail) {
 				glog.Infof("inserted forked block #%d (TD=%v) (%d TXs %d UNCs) (%x...). Took %v\n", block.Number(), block.Difficulty(), len(block.Transactions()), len(block.Uncles()), block.Hash().Bytes()[0:4], time.Since(bstart))
@@ -651,7 +647,7 @@ func (self *ChainManager) InsertChain(chain types.Blocks) (int, error) {
 			queue[i] = ChainSplitEvent{block, logs}
 			queueEvent.splitCount++
 		}
-		PutBlockReceipts(self.extraDb, block, receipts)
+		PutBlockReceipts(self.chainDb, block, receipts)
 
 		stats.processed++
 	}
@@ -733,8 +729,8 @@ func (self *ChainManager) merge(oldBlock, newBlock *types.Block) error {
 		// insert the block in the canonical way, re-writing history
 		self.insert(block)
 		// write canonical receipts and transactions
-		PutTransactions(self.extraDb, block, block.Transactions())
+		PutTransactions(self.chainDb, block, block.Transactions())
-		PutReceipts(self.extraDb, GetBlockReceipts(self.extraDb, block.Hash()))
+		PutReceipts(self.chainDb, GetBlockReceipts(self.chainDb, block.Hash()))
 
 	}
 	self.mu.Unlock()

core/chain_manager_test.go

@@ -48,14 +48,14 @@ func thePow() pow.PoW {
 
 func theChainManager(db common.Database, t *testing.T) *ChainManager {
 	var eventMux event.TypeMux
-	WriteTestNetGenesisBlock(db, db, 0)
+	WriteTestNetGenesisBlock(db, 0)
-	chainMan, err := NewChainManager(db, db, db, thePow(), &eventMux)
+	chainMan, err := NewChainManager(db, thePow(), &eventMux)
 	if err != nil {
 		t.Error("failed creating chainmanager:", err)
 		t.FailNow()
 		return nil
 	}
-	blockMan := NewBlockProcessor(db, db, nil, chainMan, &eventMux)
+	blockMan := NewBlockProcessor(db, nil, chainMan, &eventMux)
 	chainMan.SetProcessor(blockMan)
 
 	return chainMan
@@ -125,7 +125,7 @@ func testChain(chainB types.Blocks, bman *BlockProcessor) (*big.Int, error) {
 
 		bman.bc.mu.Lock()
 		{
-			WriteBlock(bman.bc.blockDb, block)
+			WriteBlock(bman.bc.chainDb, block)
 		}
 		bman.bc.mu.Unlock()
 	}
@@ -387,7 +387,7 @@ func makeChainWithDiff(genesis *types.Block, d []int, seed byte) []*types.Block
 
 func chm(genesis *types.Block, db common.Database) *ChainManager {
 	var eventMux event.TypeMux
-	bc := &ChainManager{extraDb: db, blockDb: db, stateDb: db, genesisBlock: genesis, eventMux: &eventMux, pow: FakePow{}}
+	bc := &ChainManager{chainDb: db, genesisBlock: genesis, eventMux: &eventMux, pow: FakePow{}}
 	bc.cache, _ = lru.New(100)
 	bc.futureBlocks, _ = lru.New(100)
 	bc.processor = bproc{}
@@ -399,7 +399,7 @@ func chm(genesis *types.Block, db common.Database) *ChainManager {
 func TestReorgLongest(t *testing.T) {
 	db, _ := ethdb.NewMemDatabase()
 
-	genesis, err := WriteTestNetGenesisBlock(db, db, 0)
+	genesis, err := WriteTestNetGenesisBlock(db, 0)
 	if err != nil {
 		t.Error(err)
 		t.FailNow()
@@ -422,7 +422,7 @@ func TestReorgLongest(t *testing.T) {
 
 func TestReorgShortest(t *testing.T) {
 	db, _ := ethdb.NewMemDatabase()
-	genesis, err := WriteTestNetGenesisBlock(db, db, 0)
+	genesis, err := WriteTestNetGenesisBlock(db, 0)
 	if err != nil {
 		t.Error(err)
 		t.FailNow()
@@ -446,13 +446,13 @@ func TestReorgShortest(t *testing.T) {
 func TestInsertNonceError(t *testing.T) {
 	for i := 1; i < 25 && !t.Failed(); i++ {
 		db, _ := ethdb.NewMemDatabase()
-		genesis, err := WriteTestNetGenesisBlock(db, db, 0)
+		genesis, err := WriteTestNetGenesisBlock(db, 0)
 		if err != nil {
 			t.Error(err)
 			t.FailNow()
 		}
 		bc := chm(genesis, db)
-		bc.processor = NewBlockProcessor(db, db, bc.pow, bc, bc.eventMux)
+		bc.processor = NewBlockProcessor(db, bc.pow, bc, bc.eventMux)
 		blocks := makeChain(bc.currentBlock, i, db, 0)
 
 		fail := rand.Int() % len(blocks)

core/chain_util.go

@@ -32,7 +32,7 @@ import (
 var (
 	blockHashPre  = []byte("block-hash-")
 	blockNumPre   = []byte("block-num-")
-	expDiffPeriod = big.NewInt(100000)
+	ExpDiffPeriod = big.NewInt(100000)
 )
 
 // CalcDifficulty is the difficulty adjustment algorithm. It returns
@@ -57,7 +57,7 @@ func CalcDifficulty(time, parentTime uint64, parentNumber, parentDiff *big.Int)
 	}
 
 	periodCount := new(big.Int).Add(parentNumber, common.Big1)
-	periodCount.Div(periodCount, expDiffPeriod)
+	periodCount.Div(periodCount, ExpDiffPeriod)
 	if periodCount.Cmp(common.Big1) > 0 {
 		// diff = diff + 2^(periodCount - 2)
 		expDiff := periodCount.Sub(periodCount, common.Big2)

core/execution.go

@@ -26,6 +26,7 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 )
 
+// Execution is the execution environment for the given call or create action.
 type Execution struct {
 	env     vm.Environment
 	address *common.Address
@@ -35,12 +36,15 @@ type Execution struct {
 	Gas, price, value *big.Int
 }
 
+// NewExecution returns a new execution environment that handles all calling
+// and creation logic defined by the YP.
 func NewExecution(env vm.Environment, address *common.Address, input []byte, gas, gasPrice, value *big.Int) *Execution {
 	exe := &Execution{env: env, address: address, input: input, Gas: gas, price: gasPrice, value: value}
 	exe.evm = vm.NewVm(env)
 	return exe
 }
 
+// Call executes within the given context
 func (self *Execution) Call(codeAddr common.Address, caller vm.ContextRef) ([]byte, error) {
 	// Retrieve the executing code
 	code := self.env.State().GetCode(codeAddr)
@@ -48,6 +52,9 @@ func (self *Execution) Call(codeAddr common.Address, caller vm.ContextRef) ([]by
 	return self.exec(&codeAddr, code, caller)
 }
 
+// Create creates a new contract and runs the initialisation procedure of the
+// contract. This returns the returned code for the contract and is stored
+// elsewhere.
 func (self *Execution) Create(caller vm.ContextRef) (ret []byte, err error, account *state.StateObject) {
 	// Input must be nil for create
 	code := self.input
@@ -63,16 +70,24 @@ func (self *Execution) Create(caller vm.ContextRef) (ret []byte, err error, acco
 	return
 }
 
+// exec executes the given code and executes within the contextAddr context.
 func (self *Execution) exec(contextAddr *common.Address, code []byte, caller vm.ContextRef) (ret []byte, err error) {
 	env := self.env
 	evm := self.evm
+	// Depth check execution. Fail if we're trying to execute above the
+	// limit.
 	if env.Depth() > int(params.CallCreateDepth.Int64()) {
 		caller.ReturnGas(self.Gas, self.price)
 
 		return nil, vm.DepthError
 	}
 
-	vsnapshot := env.State().Copy()
+	if !env.CanTransfer(env.State().GetStateObject(caller.Address()), self.value) {
+		caller.ReturnGas(self.Gas, self.price)
+
+		return nil, ValueTransferErr("insufficient funds to transfer value. Req %v, has %v", self.value, env.State().GetBalance(caller.Address()))
+	}
+
 	var createAccount bool
 	if self.address == nil {
 		// Generate a new address
@@ -95,15 +110,7 @@ func (self *Execution) exec(contextAddr *common.Address, code []byte, caller vm.
 	} else {
 		to = env.State().GetOrNewStateObject(*self.address)
 	}
-
+	vm.Transfer(from, to, self.value)
-	err = env.Transfer(from, to, self.value)
-	if err != nil {
-		env.State().Set(vsnapshot)
-
-		caller.ReturnGas(self.Gas, self.price)
-
-		return nil, ValueTransferErr("insufficient funds to transfer value. Req %v, has %v", self.value, from.Balance())
-	}
 
 	context := vm.NewContext(caller, to, self.value, self.Gas, self.price)
 	context.SetCallCode(contextAddr, code)

core/genesis.go

@@ -33,7 +33,7 @@ import (
 )
 
 // WriteGenesisBlock writes the genesis block to the database as block number 0
-func WriteGenesisBlock(stateDb, blockDb common.Database, reader io.Reader) (*types.Block, error) {
+func WriteGenesisBlock(chainDb common.Database, reader io.Reader) (*types.Block, error) {
 	contents, err := ioutil.ReadAll(reader)
 	if err != nil {
 		return nil, err
@@ -59,7 +59,7 @@ func WriteGenesisBlock(stateDb, blockDb common.Database, reader io.Reader) (*typ
 		return nil, err
 	}
 
-	statedb := state.New(common.Hash{}, stateDb)
+	statedb := state.New(common.Hash{}, chainDb)
 	for addr, account := range genesis.Alloc {
 		address := common.HexToAddress(addr)
 		statedb.AddBalance(address, common.String2Big(account.Balance))
@@ -84,9 +84,9 @@ func WriteGenesisBlock(stateDb, blockDb common.Database, reader io.Reader) (*typ
 	}, nil, nil, nil)
 	block.Td = difficulty
 
-	if block := GetBlockByHash(blockDb, block.Hash()); block != nil {
+	if block := GetBlockByHash(chainDb, block.Hash()); block != nil {
 		glog.V(logger.Info).Infoln("Genesis block already in chain. Writing canonical number")
-		err := WriteCanonNumber(blockDb, block)
+		err := WriteCanonNumber(chainDb, block)
 		if err != nil {
 			return nil, err
 		}
@@ -95,11 +95,11 @@ func WriteGenesisBlock(stateDb, blockDb common.Database, reader io.Reader) (*typ
 
 	statedb.Sync()
 
-	err = WriteBlock(blockDb, block)
+	err = WriteBlock(chainDb, block)
 	if err != nil {
 		return nil, err
 	}
-	err = WriteHead(blockDb, block)
+	err = WriteHead(chainDb, block)
 	if err != nil {
 		return nil, err
 	}
@@ -133,11 +133,11 @@ func WriteGenesisBlockForTesting(db common.Database, addr common.Address, balanc
 		"0x%x":{"balance":"0x%x"}
 	}
 }`, types.EncodeNonce(0), params.GenesisGasLimit.Bytes(), params.GenesisDifficulty.Bytes(), addr, balance.Bytes())
-	block, _ := WriteGenesisBlock(db, db, strings.NewReader(testGenesis))
+	block, _ := WriteGenesisBlock(db, strings.NewReader(testGenesis))
 	return block
 }
 
-func WriteTestNetGenesisBlock(stateDb, blockDb common.Database, nonce uint64) (*types.Block, error) {
+func WriteTestNetGenesisBlock(chainDb common.Database, nonce uint64) (*types.Block, error) {
 	testGenesis := fmt.Sprintf(`{
 	"nonce":"0x%x",
 	"gasLimit":"0x%x",
@@ -157,5 +157,5 @@ func WriteTestNetGenesisBlock(stateDb, blockDb common.Database, nonce uint64) (*
 		"1a26338f0d905e295fccb71fa9ea849ffa12aaf4": {"balance": "1606938044258990275541962092341162602522202993782792835301376"}
 	}
 }`, types.EncodeNonce(nonce), params.GenesisGasLimit.Bytes(), params.GenesisDifficulty.Bytes())
-	return WriteGenesisBlock(stateDb, blockDb, strings.NewReader(testGenesis))
+	return WriteGenesisBlock(chainDb, strings.NewReader(testGenesis))
 }

core/manager.go

@@ -28,8 +28,7 @@ type Backend interface {
 	BlockProcessor() *BlockProcessor
 	ChainManager() *ChainManager
 	TxPool() *TxPool
-	BlockDb() common.Database
+	ChainDb() common.Database
-	StateDb() common.Database
+	DappDb() common.Database
-	ExtraDb() common.Database
 	EventMux() *event.TypeMux
 }

core/vm/context.go

@@ -35,6 +35,7 @@ type Context struct {
 	jumpdests destinations // result of JUMPDEST analysis.
 
 	Code     []byte
+	Input    []byte
 	CodeAddr *common.Address
 
 	value, Gas, UsedGas, Price *big.Int

core/vm/contracts.go

@@ -94,7 +94,7 @@ func ecrecoverFunc(in []byte) []byte {
 	v := byte(vbig.Uint64())
 
 	if !crypto.ValidateSignatureValues(v, r, s) {
-		glog.V(logger.Error).Infof("EC RECOVER FAIL: v, r or s value invalid")
+		glog.V(logger.Debug).Infof("EC RECOVER FAIL: v, r or s value invalid")
 		return nil
 	}
 

core/vm/environment.go

@@ -36,6 +36,7 @@ type Environment interface {
 	Time() uint64
 	Difficulty() *big.Int
 	GasLimit() *big.Int
+	CanTransfer(from Account, balance *big.Int) bool
 	Transfer(from, to Account, amount *big.Int) error
 	AddLog(*state.Log)
 	AddStructLog(StructLog)

core/vm/gas.go

@@ -54,8 +54,8 @@ func baseCheck(op OpCode, stack *stack, gas *big.Int) error {
 			return err
 		}
 
-		if r.stackPush > 0 && len(stack.data)-r.stackPop+r.stackPush > int(params.StackLimit.Int64())+1 {
+		if r.stackPush > 0 && stack.len()-r.stackPop+r.stackPush > int(params.StackLimit.Int64()) {
-			return fmt.Errorf("stack limit reached %d (%d)", len(stack.data), params.StackLimit.Int64())
+			return fmt.Errorf("stack limit reached %d (%d)", stack.len(), params.StackLimit.Int64())
 		}
 
 		gas.Add(gas, r.gas)

core/vm/instructions.go

@@ -0,0 +1,537 @@
+// Copyright 2014 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package vm
+
+import (
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/params"
+)
+
+type instrFn func(instr instruction, env Environment, context *Context, memory *Memory, stack *stack)
+type instrExFn func(instr instruction, ret *big.Int, env Environment, context *Context, memory *Memory, stack *stack)
+
+type instruction struct {
+	op     OpCode
+	pc     uint64
+	fn     instrFn
+	specFn instrExFn
+	data   *big.Int
+
+	gas   *big.Int
+	spop  int
+	spush int
+}
+
+func opStaticJump(instr instruction, ret *big.Int, env Environment, context *Context, memory *Memory, stack *stack) {
+	ret.Set(instr.data)
+}
+
+func opAdd(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x, y := stack.pop(), stack.pop()
+	stack.push(U256(x.Add(x, y)))
+}
+
+func opSub(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x, y := stack.pop(), stack.pop()
+	stack.push(U256(x.Sub(x, y)))
+}
+
+func opMul(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x, y := stack.pop(), stack.pop()
+	stack.push(U256(x.Mul(x, y)))
+}
+
+func opDiv(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x, y := stack.pop(), stack.pop()
+	if y.Cmp(common.Big0) != 0 {
+		stack.push(U256(x.Div(x, y)))
+	} else {
+		stack.push(new(big.Int))
+	}
+}
+
+func opSdiv(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x, y := S256(stack.pop()), S256(stack.pop())
+	if y.Cmp(common.Big0) == 0 {
+		stack.push(new(big.Int))
+		return
+	} else {
+		n := new(big.Int)
+		if new(big.Int).Mul(x, y).Cmp(common.Big0) < 0 {
+			n.SetInt64(-1)
+		} else {
+			n.SetInt64(1)
+		}
+
+		res := x.Div(x.Abs(x), y.Abs(y))
+		res.Mul(res, n)
+
+		stack.push(U256(res))
+	}
+}
+
+func opMod(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x, y := stack.pop(), stack.pop()
+	if y.Cmp(common.Big0) == 0 {
+		stack.push(new(big.Int))
+	} else {
+		stack.push(U256(x.Mod(x, y)))
+	}
+}
+
+func opSmod(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x, y := S256(stack.pop()), S256(stack.pop())
+
+	if y.Cmp(common.Big0) == 0 {
+		stack.push(new(big.Int))
+	} else {
+		n := new(big.Int)
+		if x.Cmp(common.Big0) < 0 {
+			n.SetInt64(-1)
+		} else {
+			n.SetInt64(1)
+		}
+
+		res := x.Mod(x.Abs(x), y.Abs(y))
+		res.Mul(res, n)
+
+		stack.push(U256(res))
+	}
+}
+
+func opExp(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x, y := stack.pop(), stack.pop()
+	stack.push(U256(x.Exp(x, y, Pow256)))
+}
+
+func opSignExtend(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	back := stack.pop()
+	if back.Cmp(big.NewInt(31)) < 0 {
+		bit := uint(back.Uint64()*8 + 7)
+		num := stack.pop()
+		mask := back.Lsh(common.Big1, bit)
+		mask.Sub(mask, common.Big1)
+		if common.BitTest(num, int(bit)) {
+			num.Or(num, mask.Not(mask))
+		} else {
+			num.And(num, mask)
+		}
+
+		stack.push(U256(num))
+	}
+}
+
+func opNot(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x := stack.pop()
+	stack.push(U256(x.Not(x)))
+}
+
+func opLt(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x, y := stack.pop(), stack.pop()
+	if x.Cmp(y) < 0 {
+		stack.push(big.NewInt(1))
+	} else {
+		stack.push(new(big.Int))
+	}
+}
+
+func opGt(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x, y := stack.pop(), stack.pop()
+	if x.Cmp(y) > 0 {
+		stack.push(big.NewInt(1))
+	} else {
+		stack.push(new(big.Int))
+	}
+}
+
+func opSlt(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x, y := S256(stack.pop()), S256(stack.pop())
+	if x.Cmp(S256(y)) < 0 {
+		stack.push(big.NewInt(1))
+	} else {
+		stack.push(new(big.Int))
+	}
+}
+
+func opSgt(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x, y := S256(stack.pop()), S256(stack.pop())
+	if x.Cmp(y) > 0 {
+		stack.push(big.NewInt(1))
+	} else {
+		stack.push(new(big.Int))
+	}
+}
+
+func opEq(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x, y := stack.pop(), stack.pop()
+	if x.Cmp(y) == 0 {
+		stack.push(big.NewInt(1))
+	} else {
+		stack.push(new(big.Int))
+	}
+}
+
+func opIszero(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x := stack.pop()
+	if x.Cmp(common.Big0) > 0 {
+		stack.push(new(big.Int))
+	} else {
+		stack.push(big.NewInt(1))
+	}
+}
+
+func opAnd(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x, y := stack.pop(), stack.pop()
+	stack.push(x.And(x, y))
+}
+func opOr(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x, y := stack.pop(), stack.pop()
+	stack.push(x.Or(x, y))
+}
+func opXor(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x, y := stack.pop(), stack.pop()
+	stack.push(x.Xor(x, y))
+}
+func opByte(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	th, val := stack.pop(), stack.pop()
+	if th.Cmp(big.NewInt(32)) < 0 {
+		byte := big.NewInt(int64(common.LeftPadBytes(val.Bytes(), 32)[th.Int64()]))
+		stack.push(byte)
+	} else {
+		stack.push(new(big.Int))
+	}
+}
+func opAddmod(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x, y, z := stack.pop(), stack.pop(), stack.pop()
+	if z.Cmp(Zero) > 0 {
+		add := x.Add(x, y)
+		add.Mod(add, z)
+		stack.push(U256(add))
+	} else {
+		stack.push(new(big.Int))
+	}
+}
+func opMulmod(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	x, y, z := stack.pop(), stack.pop(), stack.pop()
+	if z.Cmp(Zero) > 0 {
+		mul := x.Mul(x, y)
+		mul.Mod(mul, z)
+		stack.push(U256(mul))
+	} else {
+		stack.push(new(big.Int))
+	}
+}
+
+func opSha3(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	offset, size := stack.pop(), stack.pop()
+	hash := crypto.Sha3(memory.Get(offset.Int64(), size.Int64()))
+
+	stack.push(common.BytesToBig(hash))
+}
+
+func opAddress(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.push(common.Bytes2Big(context.Address().Bytes()))
+}
+
+func opBalance(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	addr := common.BigToAddress(stack.pop())
+	balance := env.State().GetBalance(addr)
+
+	stack.push(new(big.Int).Set(balance))
+}
+
+func opOrigin(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.push(env.Origin().Big())
+}
+
+func opCaller(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.push(common.Bytes2Big(context.caller.Address().Bytes()))
+}
+
+func opCallValue(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.push(new(big.Int).Set(context.value))
+}
+
+func opCalldataLoad(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.push(common.Bytes2Big(getData(context.Input, stack.pop(), common.Big32)))
+}
+
+func opCalldataSize(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.push(big.NewInt(int64(len(context.Input))))
+}
+
+func opCalldataCopy(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	var (
+		mOff = stack.pop()
+		cOff = stack.pop()
+		l    = stack.pop()
+	)
+	memory.Set(mOff.Uint64(), l.Uint64(), getData(context.Input, cOff, l))
+}
+
+func opExtCodeSize(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	addr := common.BigToAddress(stack.pop())
+	l := big.NewInt(int64(len(env.State().GetCode(addr))))
+	stack.push(l)
+}
+
+func opCodeSize(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	l := big.NewInt(int64(len(context.Code)))
+	stack.push(l)
+}
+
+func opCodeCopy(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	var (
+		mOff = stack.pop()
+		cOff = stack.pop()
+		l    = stack.pop()
+	)
+	codeCopy := getData(context.Code, cOff, l)
+
+	memory.Set(mOff.Uint64(), l.Uint64(), codeCopy)
+}
+
+func opExtCodeCopy(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	var (
+		addr = common.BigToAddress(stack.pop())
+		mOff = stack.pop()
+		cOff = stack.pop()
+		l    = stack.pop()
+	)
+	codeCopy := getData(env.State().GetCode(addr), cOff, l)
+
+	memory.Set(mOff.Uint64(), l.Uint64(), codeCopy)
+}
+
+func opGasprice(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.push(new(big.Int).Set(context.Price))
+}
+
+func opBlockhash(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	num := stack.pop()
+
+	n := new(big.Int).Sub(env.BlockNumber(), common.Big257)
+	if num.Cmp(n) > 0 && num.Cmp(env.BlockNumber()) < 0 {
+		stack.push(env.GetHash(num.Uint64()).Big())
+	} else {
+		stack.push(new(big.Int))
+	}
+}
+
+func opCoinbase(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.push(env.Coinbase().Big())
+}
+
+func opTimestamp(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.push(new(big.Int).SetUint64(env.Time()))
+}
+
+func opNumber(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.push(U256(env.BlockNumber()))
+}
+
+func opDifficulty(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.push(new(big.Int).Set(env.Difficulty()))
+}
+
+func opGasLimit(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.push(new(big.Int).Set(env.GasLimit()))
+}
+
+func opPop(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.pop()
+}
+
+func opPush(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.push(new(big.Int).Set(instr.data))
+}
+
+func opDup(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.dup(int(instr.data.Int64()))
+}
+
+func opSwap(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.swap(int(instr.data.Int64()))
+}
+
+func opLog(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	n := int(instr.data.Int64())
+	topics := make([]common.Hash, n)
+	mStart, mSize := stack.pop(), stack.pop()
+	for i := 0; i < n; i++ {
+		topics[i] = common.BigToHash(stack.pop())
+	}
+
+	d := memory.Get(mStart.Int64(), mSize.Int64())
+	log := state.NewLog(context.Address(), topics, d, env.BlockNumber().Uint64())
+	env.AddLog(log)
+}
+
+func opMload(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	offset := stack.pop()
+	val := common.BigD(memory.Get(offset.Int64(), 32))
+	stack.push(val)
+}
+
+func opMstore(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	// pop value of the stack
+	mStart, val := stack.pop(), stack.pop()
+	memory.Set(mStart.Uint64(), 32, common.BigToBytes(val, 256))
+}
+
+func opMstore8(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	off, val := stack.pop().Int64(), stack.pop().Int64()
+	memory.store[off] = byte(val & 0xff)
+}
+
+func opSload(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	loc := common.BigToHash(stack.pop())
+	val := env.State().GetState(context.Address(), loc).Big()
+	stack.push(val)
+}
+
+func opSstore(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	loc := common.BigToHash(stack.pop())
+	val := stack.pop()
+
+	env.State().SetState(context.Address(), loc, common.BigToHash(val))
+}
+
+func opJump(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+}
+func opJumpi(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+}
+func opJumpdest(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+}
+
+func opPc(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.push(instr.data)
+}
+
+func opMsize(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.push(big.NewInt(int64(memory.Len())))
+}
+
+func opGas(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	stack.push(new(big.Int).Set(context.Gas))
+}
+
+func opCreate(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	var (
+		value        = stack.pop()
+		offset, size = stack.pop(), stack.pop()
+		input        = memory.Get(offset.Int64(), size.Int64())
+		gas          = new(big.Int).Set(context.Gas)
+		addr         common.Address
+	)
+
+	context.UseGas(context.Gas)
+	ret, suberr, ref := env.Create(context, input, gas, context.Price, value)
+	if suberr != nil {
+		stack.push(new(big.Int))
+
+	} else {
+		// gas < len(ret) * Createinstr.dataGas == NO_CODE
+		dataGas := big.NewInt(int64(len(ret)))
+		dataGas.Mul(dataGas, params.CreateDataGas)
+		if context.UseGas(dataGas) {
+			ref.SetCode(ret)
+		}
+		addr = ref.Address()
+
+		stack.push(addr.Big())
+
+	}
+}
+
+func opCall(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	gas := stack.pop()
+	// pop gas and value of the stack.
+	addr, value := stack.pop(), stack.pop()
+	value = U256(value)
+	// pop input size and offset
+	inOffset, inSize := stack.pop(), stack.pop()
+	// pop return size and offset
+	retOffset, retSize := stack.pop(), stack.pop()
+
+	address := common.BigToAddress(addr)
+
+	// Get the arguments from the memory
+	args := memory.Get(inOffset.Int64(), inSize.Int64())
+
+	if len(value.Bytes()) > 0 {
+		gas.Add(gas, params.CallStipend)
+	}
+
+	ret, err := env.Call(context, address, args, gas, context.Price, value)
+
+	if err != nil {
+		stack.push(new(big.Int))
+
+	} else {
+		stack.push(big.NewInt(1))
+
+		memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
+	}
+}
+
+func opCallCode(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	gas := stack.pop()
+	// pop gas and value of the stack.
+	addr, value := stack.pop(), stack.pop()
+	value = U256(value)
+	// pop input size and offset
+	inOffset, inSize := stack.pop(), stack.pop()
+	// pop return size and offset
+	retOffset, retSize := stack.pop(), stack.pop()
+
+	address := common.BigToAddress(addr)
+
+	// Get the arguments from the memory
+	args := memory.Get(inOffset.Int64(), inSize.Int64())
+
+	if len(value.Bytes()) > 0 {
+		gas.Add(gas, params.CallStipend)
+	}
+
+	ret, err := env.CallCode(context, address, args, gas, context.Price, value)
+
+	if err != nil {
+		stack.push(new(big.Int))
+
+	} else {
+		stack.push(big.NewInt(1))
+
+		memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
+	}
+}
+
+func opReturn(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {}
+func opStop(instr instruction, env Environment, context *Context, memory *Memory, stack *stack)   {}
+
+func opSuicide(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
+	receiver := env.State().GetOrNewStateObject(common.BigToAddress(stack.pop()))
+	balance := env.State().GetBalance(context.Address())
+
+	receiver.AddBalance(balance)
+
+	env.State().Delete(context.Address())
+}

core/vm/jit.go

@@ -0,0 +1,541 @@
+// Copyright 2014 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package vm
+
+import (
+	"fmt"
+	"math/big"
+	"sync/atomic"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/hashicorp/golang-lru"
+)
+
+type progStatus int32
+
+const (
+	progUnknown progStatus = iota
+	progCompile
+	progReady
+	progError
+)
+
+var programs *lru.Cache
+
+func init() {
+	programs, _ = lru.New(defaultJitMaxCache)
+}
+
+// SetJITCacheSize recreates the program cache with the max given size. Setting
+// a new cache is **not** thread safe. Use with caution.
+func SetJITCacheSize(size int) {
+	programs, _ = lru.New(size)
+}
+
+// GetProgram returns the program by id or nil when non-existent
+func GetProgram(id common.Hash) *Program {
+	if p, ok := programs.Get(id); ok {
+		return p.(*Program)
+	}
+
+	return nil
+}
+
+// GenProgramStatus returns the status of the given program id
+func GetProgramStatus(id common.Hash) progStatus {
+	program := GetProgram(id)
+	if program != nil {
+		return progStatus(atomic.LoadInt32(&program.status))
+	}
+
+	return progUnknown
+}
+
+// Program is a compiled program for the JIT VM and holds all required for
+// running a compiled JIT program.
+type Program struct {
+	Id     common.Hash // Id of the program
+	status int32       // status should be accessed atomically
+
+	context *Context
+
+	instructions []instruction       // instruction set
+	mapping      map[uint64]int      // real PC mapping to array indices
+	destinations map[uint64]struct{} // cached jump destinations
+
+	code []byte
+}
+
+func NewProgram(code []byte) *Program {
+	program := &Program{
+		Id:           crypto.Sha3Hash(code),
+		mapping:      make(map[uint64]int),
+		destinations: make(map[uint64]struct{}),
+		code:         code,
+	}
+
+	programs.Add(program.Id, program)
+	return program
+}
+
+func (p *Program) addInstr(op OpCode, pc uint64, fn instrFn, data *big.Int) {
+	// PUSH and DUP are a bit special. They all cost the same but we do want to have checking on stack push limit
+	// PUSH is also allowed to calculate the same price for all PUSHes
+	// DUP requirements are handled elsewhere (except for the stack limit check)
+	baseOp := op
+	if op >= PUSH1 && op <= PUSH32 {
+		baseOp = PUSH1
+	}
+	if op >= DUP1 && op <= DUP16 {
+		baseOp = DUP1
+	}
+	base := _baseCheck[baseOp]
+	instr := instruction{op, pc, fn, nil, data, base.gas, base.stackPop, base.stackPush}
+
+	p.instructions = append(p.instructions, instr)
+	p.mapping[pc] = len(p.instructions) - 1
+}
+
+func CompileProgram(program *Program) (err error) {
+	if progStatus(atomic.LoadInt32(&program.status)) == progCompile {
+		return nil
+	}
+	atomic.StoreInt32(&program.status, int32(progCompile))
+	defer func() {
+		if err != nil {
+			atomic.StoreInt32(&program.status, int32(progError))
+		} else {
+			atomic.StoreInt32(&program.status, int32(progReady))
+		}
+	}()
+
+	// loop thru the opcodes and "compile" in to instructions
+	for pc := uint64(0); pc < uint64(len(program.code)); pc++ {
+		switch op := OpCode(program.code[pc]); op {
+		case ADD:
+			program.addInstr(op, pc, opAdd, nil)
+		case SUB:
+			program.addInstr(op, pc, opSub, nil)
+		case MUL:
+			program.addInstr(op, pc, opMul, nil)
+		case DIV:
+			program.addInstr(op, pc, opDiv, nil)
+		case SDIV:
+			program.addInstr(op, pc, opSdiv, nil)
+		case MOD:
+			program.addInstr(op, pc, opMod, nil)
+		case SMOD:
+			program.addInstr(op, pc, opSmod, nil)
+		case EXP:
+			program.addInstr(op, pc, opExp, nil)
+		case SIGNEXTEND:
+			program.addInstr(op, pc, opSignExtend, nil)
+		case NOT:
+			program.addInstr(op, pc, opNot, nil)
+		case LT:
+			program.addInstr(op, pc, opLt, nil)
+		case GT:
+			program.addInstr(op, pc, opGt, nil)
+		case SLT:
+			program.addInstr(op, pc, opSlt, nil)
+		case SGT:
+			program.addInstr(op, pc, opSgt, nil)
+		case EQ:
+			program.addInstr(op, pc, opEq, nil)
+		case ISZERO:
+			program.addInstr(op, pc, opIszero, nil)
+		case AND:
+			program.addInstr(op, pc, opAnd, nil)
+		case OR:
+			program.addInstr(op, pc, opOr, nil)
+		case XOR:
+			program.addInstr(op, pc, opXor, nil)
+		case BYTE:
+			program.addInstr(op, pc, opByte, nil)
+		case ADDMOD:
+			program.addInstr(op, pc, opAddmod, nil)
+		case MULMOD:
+			program.addInstr(op, pc, opMulmod, nil)
+		case SHA3:
+			program.addInstr(op, pc, opSha3, nil)
+		case ADDRESS:
+			program.addInstr(op, pc, opAddress, nil)
+		case BALANCE:
+			program.addInstr(op, pc, opBalance, nil)
+		case ORIGIN:
+			program.addInstr(op, pc, opOrigin, nil)
+		case CALLER:
+			program.addInstr(op, pc, opCaller, nil)
+		case CALLVALUE:
+			program.addInstr(op, pc, opCallValue, nil)
+		case CALLDATALOAD:
+			program.addInstr(op, pc, opCalldataLoad, nil)
+		case CALLDATASIZE:
+			program.addInstr(op, pc, opCalldataSize, nil)
+		case CALLDATACOPY:
+			program.addInstr(op, pc, opCalldataCopy, nil)
+		case CODESIZE:
+			program.addInstr(op, pc, opCodeSize, nil)
+		case EXTCODESIZE:
+			program.addInstr(op, pc, opExtCodeSize, nil)
+		case CODECOPY:
+			program.addInstr(op, pc, opCodeCopy, nil)
+		case EXTCODECOPY:
+			program.addInstr(op, pc, opExtCodeCopy, nil)
+		case GASPRICE:
+			program.addInstr(op, pc, opGasprice, nil)
+		case BLOCKHASH:
+			program.addInstr(op, pc, opBlockhash, nil)
+		case COINBASE:
+			program.addInstr(op, pc, opCoinbase, nil)
+		case TIMESTAMP:
+			program.addInstr(op, pc, opTimestamp, nil)
+		case NUMBER:
+			program.addInstr(op, pc, opNumber, nil)
+		case DIFFICULTY:
+			program.addInstr(op, pc, opDifficulty, nil)
+		case GASLIMIT:
+			program.addInstr(op, pc, opGasLimit, nil)
+		case PUSH1, PUSH2, PUSH3, PUSH4, PUSH5, PUSH6, PUSH7, PUSH8, PUSH9, PUSH10, PUSH11, PUSH12, PUSH13, PUSH14, PUSH15, PUSH16, PUSH17, PUSH18, PUSH19, PUSH20, PUSH21, PUSH22, PUSH23, PUSH24, PUSH25, PUSH26, PUSH27, PUSH28, PUSH29, PUSH30, PUSH31, PUSH32:
+			size := uint64(op - PUSH1 + 1)
+			bytes := getData([]byte(program.code), new(big.Int).SetUint64(pc+1), new(big.Int).SetUint64(size))
+
+			program.addInstr(op, pc, opPush, common.Bytes2Big(bytes))
+
+			pc += size
+
+		case POP:
+			program.addInstr(op, pc, opPop, nil)
+		case DUP1, DUP2, DUP3, DUP4, DUP5, DUP6, DUP7, DUP8, DUP9, DUP10, DUP11, DUP12, DUP13, DUP14, DUP15, DUP16:
+			program.addInstr(op, pc, opDup, big.NewInt(int64(op-DUP1+1)))
+		case SWAP1, SWAP2, SWAP3, SWAP4, SWAP5, SWAP6, SWAP7, SWAP8, SWAP9, SWAP10, SWAP11, SWAP12, SWAP13, SWAP14, SWAP15, SWAP16:
+			program.addInstr(op, pc, opSwap, big.NewInt(int64(op-SWAP1+2)))
+		case LOG0, LOG1, LOG2, LOG3, LOG4:
+			program.addInstr(op, pc, opLog, big.NewInt(int64(op-LOG0)))
+		case MLOAD:
+			program.addInstr(op, pc, opMload, nil)
+		case MSTORE:
+			program.addInstr(op, pc, opMstore, nil)
+		case MSTORE8:
+			program.addInstr(op, pc, opMstore8, nil)
+		case SLOAD:
+			program.addInstr(op, pc, opSload, nil)
+		case SSTORE:
+			program.addInstr(op, pc, opSstore, nil)
+		case JUMP:
+			program.addInstr(op, pc, opJump, nil)
+		case JUMPI:
+			program.addInstr(op, pc, opJumpi, nil)
+		case JUMPDEST:
+			program.addInstr(op, pc, opJumpdest, nil)
+			program.destinations[pc] = struct{}{}
+		case PC:
+			program.addInstr(op, pc, opPc, big.NewInt(int64(pc)))
+		case MSIZE:
+			program.addInstr(op, pc, opMsize, nil)
+		case GAS:
+			program.addInstr(op, pc, opGas, nil)
+		case CREATE:
+			program.addInstr(op, pc, opCreate, nil)
+		case CALL:
+			program.addInstr(op, pc, opCall, nil)
+		case CALLCODE:
+			program.addInstr(op, pc, opCallCode, nil)
+		case RETURN:
+			program.addInstr(op, pc, opReturn, nil)
+		case SUICIDE:
+			program.addInstr(op, pc, opSuicide, nil)
+		case STOP: // Stop the context
+			program.addInstr(op, pc, opStop, nil)
+		default:
+			program.addInstr(op, pc, nil, nil)
+		}
+	}
+
+	return nil
+}
+
+func RunProgram(program *Program, env Environment, context *Context, input []byte) ([]byte, error) {
+	return runProgram(program, 0, NewMemory(), newstack(), env, context, input)
+}
+
+func runProgram(program *Program, pcstart uint64, mem *Memory, stack *stack, env Environment, context *Context, input []byte) ([]byte, error) {
+	context.Input = input
+
+	var (
+		caller      = context.caller
+		statedb     = env.State()
+		pc      int = program.mapping[pcstart]
+
+		jump = func(to *big.Int) error {
+			if !validDest(program.destinations, to) {
+				nop := context.GetOp(to.Uint64())
+				return fmt.Errorf("invalid jump destination (%v) %v", nop, to)
+			}
+
+			pc = program.mapping[to.Uint64()]
+
+			return nil
+		}
+	)
+
+	for pc < len(program.instructions) {
+		instr := program.instructions[pc]
+
+		// calculate the new memory size and gas price for the current executing opcode
+		newMemSize, cost, err := jitCalculateGasAndSize(env, context, caller, instr, statedb, mem, stack)
+		if err != nil {
+			return nil, err
+		}
+
+		// Use the calculated gas. When insufficient gas is present, use all gas and return an
+		// Out Of Gas error
+		if !context.UseGas(cost) {
+			return nil, OutOfGasError
+		}
+		// Resize the memory calculated previously
+		mem.Resize(newMemSize.Uint64())
+
+		// These opcodes return an argument and are thefor handled
+		// differently from the rest of the opcodes
+		switch instr.op {
+		case JUMP:
+			if err := jump(stack.pop()); err != nil {
+				return nil, err
+			}
+			continue
+		case JUMPI:
+			pos, cond := stack.pop(), stack.pop()
+
+			if cond.Cmp(common.BigTrue) >= 0 {
+				if err := jump(pos); err != nil {
+					return nil, err
+				}
+				continue
+			}
+		case RETURN:
+			offset, size := stack.pop(), stack.pop()
+			ret := mem.GetPtr(offset.Int64(), size.Int64())
+
+			return context.Return(ret), nil
+		case SUICIDE:
+			instr.fn(instr, env, context, mem, stack)
+
+			return context.Return(nil), nil
+		case STOP:
+			return context.Return(nil), nil
+		default:
+			if instr.fn == nil {
+				return nil, fmt.Errorf("Invalid opcode %x", instr.op)
+			}
+
+			instr.fn(instr, env, context, mem, stack)
+		}
+
+		pc++
+	}
+
+	return context.Return(nil), nil
+}
+
+// validDest checks if the given distination is a valid one given the
+// destination table of the program
+func validDest(dests map[uint64]struct{}, dest *big.Int) bool {
+	// PC cannot go beyond len(code) and certainly can't be bigger than 64bits.
+	// Don't bother checking for JUMPDEST in that case.
+	if dest.Cmp(bigMaxUint64) > 0 {
+		return false
+	}
+	_, ok := dests[dest.Uint64()]
+	return ok
+}
+
+// jitCalculateGasAndSize 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 jitCalculateGasAndSize(env Environment, context *Context, caller ContextRef, instr instruction, statedb *state.StateDB, mem *Memory, stack *stack) (*big.Int, *big.Int, error) {
+	var (
+		gas                 = new(big.Int)
+		newMemSize *big.Int = new(big.Int)
+	)
+	err := jitBaseCheck(instr, stack, gas)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// stack Check, memory resize & gas phase
+	switch op := instr.op; op {
+	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)
+		if err != nil {
+			return nil, nil, err
+		}
+		gas.Set(GasFastestStep)
+	case DUP1, DUP2, DUP3, DUP4, DUP5, DUP6, DUP7, DUP8, DUP9, DUP10, DUP11, DUP12, DUP13, DUP14, DUP15, DUP16:
+		n := int(op - DUP1 + 1)
+		err := stack.require(n)
+		if err != nil {
+			return nil, nil, err
+		}
+		gas.Set(GasFastestStep)
+	case LOG0, LOG1, LOG2, LOG3, LOG4:
+		n := int(op - LOG0)
+		err := stack.require(n + 2)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		mSize, mStart := stack.data[stack.len()-2], stack.data[stack.len()-1]
+
+		add := new(big.Int)
+		gas.Add(gas, params.LogGas)
+		gas.Add(gas, add.Mul(big.NewInt(int64(n)), params.LogTopicGas))
+		gas.Add(gas, add.Mul(mSize, params.LogDataGas))
+
+		newMemSize = calcMemSize(mStart, mSize)
+	case EXP:
+		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 {
+			return nil, nil, err
+		}
+
+		var g *big.Int
+		y, x := stack.data[stack.len()-2], stack.data[stack.len()-1]
+		val := statedb.GetState(context.Address(), common.BigToHash(x))
+
+		// This checks for 3 scenario's and calculates gas accordingly
+		// 1. From a zero-value address to a non-zero value         (NEW VALUE)
+		// 2. From a non-zero value address to a zero-value address (DELETE)
+		// 3. From a nen-zero to a non-zero                         (CHANGE)
+		if common.EmptyHash(val) && !common.EmptyHash(common.BigToHash(y)) {
+			// 0 => non 0
+			g = params.SstoreSetGas
+		} else if !common.EmptyHash(val) && common.EmptyHash(common.BigToHash(y)) {
+			statedb.Refund(params.SstoreRefundGas)
+
+			g = params.SstoreClearGas
+		} else {
+			// non 0 => non 0 (or 0 => 0)
+			g = params.SstoreClearGas
+		}
+		gas.Set(g)
+	case SUICIDE:
+		if !statedb.IsDeleted(context.Address()) {
+			statedb.Refund(params.SuicideRefundGas)
+		}
+	case MLOAD:
+		newMemSize = calcMemSize(stack.peek(), u256(32))
+	case MSTORE8:
+		newMemSize = calcMemSize(stack.peek(), u256(1))
+	case MSTORE:
+		newMemSize = calcMemSize(stack.peek(), u256(32))
+	case RETURN:
+		newMemSize = calcMemSize(stack.peek(), stack.data[stack.len()-2])
+	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))
+	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))
+	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))
+	case 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))
+
+	case CREATE:
+		newMemSize = calcMemSize(stack.data[stack.len()-2], stack.data[stack.len()-3])
+	case CALL, CALLCODE:
+		gas.Add(gas, stack.data[stack.len()-1])
+
+		if op == CALL {
+			if env.State().GetStateObject(common.BigToAddress(stack.data[stack.len()-2])) == nil {
+				gas.Add(gas, params.CallNewAccountGas)
+			}
+		}
+
+		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)
+	}
+
+	if newMemSize.Cmp(common.Big0) > 0 {
+		newMemSizeWords := toWordSize(newMemSize)
+		newMemSize.Mul(newMemSizeWords, u256(32))
+
+		if newMemSize.Cmp(u256(int64(mem.Len()))) > 0 {
+			// be careful reusing variables here when changing.
+			// The order has been optimised to reduce allocation
+			oldSize := toWordSize(big.NewInt(int64(mem.Len())))
+			pow := new(big.Int).Exp(oldSize, common.Big2, Zero)
+			linCoef := oldSize.Mul(oldSize, params.MemoryGas)
+			quadCoef := new(big.Int).Div(pow, params.QuadCoeffDiv)
+			oldTotalFee := new(big.Int).Add(linCoef, quadCoef)
+
+			pow.Exp(newMemSizeWords, common.Big2, Zero)
+			linCoef = linCoef.Mul(newMemSizeWords, params.MemoryGas)
+			quadCoef = quadCoef.Div(pow, params.QuadCoeffDiv)
+			newTotalFee := linCoef.Add(linCoef, quadCoef)
+
+			fee := newTotalFee.Sub(newTotalFee, oldTotalFee)
+			gas.Add(gas, fee)
+		}
+	}
+
+	return newMemSize, gas, nil
+}
+
+// jitBaseCheck is the same as baseCheck except it doesn't do the look up in the
+// gas table. This is done during compilation instead.
+func jitBaseCheck(instr instruction, stack *stack, gas *big.Int) error {
+	err := stack.require(instr.spop)
+	if err != nil {
+		return err
+	}
+
+	if instr.spush > 0 && stack.len()-instr.spop+instr.spush > int(params.StackLimit.Int64()) {
+		return fmt.Errorf("stack limit reached %d (%d)", stack.len(), params.StackLimit.Int64())
+	}
+
+	// nil on gas means no base calculation
+	if instr.gas == nil {
+		return nil
+	}
+
+	gas.Add(gas, instr.gas)
+
+	return nil
+}

core/vm/jit_test.go

@@ -0,0 +1,122 @@
+// Copyright 2014 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+package vm
+
+import (
+	"math/big"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethdb"
+)
+
+const maxRun = 1000
+
+type vmBench struct {
+	precompile bool // compile prior to executing
+	nojit      bool // ignore jit (sets DisbaleJit = true
+	forcejit   bool // forces the jit, precompile is ignored
+
+	code  []byte
+	input []byte
+}
+
+func runVmBench(test vmBench, b *testing.B) {
+	db, _ := ethdb.NewMemDatabase()
+	sender := state.NewStateObject(common.Address{}, db)
+
+	if test.precompile && !test.forcejit {
+		NewProgram(test.code)
+	}
+	env := NewEnv()
+
+	DisableJit = test.nojit
+	ForceJit = test.forcejit
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		context := NewContext(sender, sender, big.NewInt(100), big.NewInt(10000), big.NewInt(0))
+		context.Code = test.code
+		context.CodeAddr = &common.Address{}
+		_, err := New(env).Run(context, test.input)
+		if err != nil {
+			b.Error(err)
+			b.FailNow()
+		}
+	}
+}
+
+var benchmarks = map[string]vmBench{
+	"pushes": vmBench{
+		false, false, false,
+		common.Hex2Bytes("600a600a01600a600a01600a600a01600a600a01600a600a01600a600a01600a600a01600a600a01600a600a01600a600a01"), nil,
+	},
+}
+
+func BenchmarkPushes(b *testing.B) {
+	runVmBench(benchmarks["pushes"], b)
+}
+
+type Env struct {
+	gasLimit *big.Int
+	depth    int
+}
+
+func NewEnv() *Env {
+	return &Env{big.NewInt(10000), 0}
+}
+
+func (self *Env) Origin() common.Address { return common.Address{} }
+func (self *Env) BlockNumber() *big.Int  { return big.NewInt(0) }
+func (self *Env) AddStructLog(log StructLog) {
+}
+func (self *Env) StructLogs() []StructLog {
+	return nil
+}
+
+//func (self *Env) PrevHash() []byte      { return self.parent }
+func (self *Env) Coinbase() common.Address { return common.Address{} }
+func (self *Env) Time() uint64             { return uint64(time.Now().Unix()) }
+func (self *Env) Difficulty() *big.Int     { return big.NewInt(0) }
+func (self *Env) State() *state.StateDB    { return nil }
+func (self *Env) GasLimit() *big.Int       { return self.gasLimit }
+func (self *Env) VmType() Type             { return StdVmTy }
+func (self *Env) GetHash(n uint64) common.Hash {
+	return common.BytesToHash(crypto.Sha3([]byte(big.NewInt(int64(n)).String())))
+}
+func (self *Env) AddLog(log *state.Log) {
+}
+func (self *Env) Depth() int     { return self.depth }
+func (self *Env) SetDepth(i int) { self.depth = i }
+func (self *Env) CanTransfer(from Account, balance *big.Int) bool {
+	return from.Balance().Cmp(balance) >= 0
+}
+func (self *Env) Transfer(from, to Account, amount *big.Int) error {
+	return nil
+}
+func (self *Env) Call(caller ContextRef, addr common.Address, data []byte, gas, price, value *big.Int) ([]byte, error) {
+	return nil, nil
+}
+func (self *Env) CallCode(caller ContextRef, addr common.Address, data []byte, gas, price, value *big.Int) ([]byte, error) {
+	return nil, nil
+}
+func (self *Env) Create(caller ContextRef, data []byte, gas, price, value *big.Int) ([]byte, error, ContextRef) {
+	return nil, nil, nil
+}

core/vm/settings.go

@@ -0,0 +1,25 @@
+// Copyright 2014 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package vm
+
+var (
+	DisableJit  bool = true // Disable the JIT VM
+	ForceJit    bool        // Force the JIT, skip byte VM
+	MaxProgSize int         // Max cache size for JIT Programs
+)
+
+const defaultJitMaxCache int = 64

core/vm/stack.go

@@ -21,38 +21,36 @@ import (
 	"math/big"
 )
 
+// stack is an object for basic stack operations. Items popped to the stack are
+// expected to be changed and modified. stack does not take care of adding newly
+// initialised objects.
+type stack struct {
+	data []*big.Int
+}
+
 func newstack() *stack {
 	return &stack{}
 }
 
-type stack struct {
-	data []*big.Int
-	ptr  int
-}
-
 func (st *stack) Data() []*big.Int {
-	return st.data[:st.ptr]
+	return st.data
 }
 
 func (st *stack) push(d *big.Int) {
 	// NOTE push limit (1024) is checked in baseCheck
-	stackItem := new(big.Int).Set(d)
+	//stackItem := new(big.Int).Set(d)
-	if len(st.data) > st.ptr {
+	//st.data = append(st.data, stackItem)
-		st.data[st.ptr] = stackItem
+	st.data = append(st.data, d)
-	} else {
-		st.data = append(st.data, stackItem)
-	}
-	st.ptr++
 }
 
 func (st *stack) pop() (ret *big.Int) {
-	st.ptr--
+	ret = st.data[len(st.data)-1]
-	ret = st.data[st.ptr]
+	st.data = st.data[:len(st.data)-1]
 	return
 }
 
 func (st *stack) len() int {
-	return st.ptr
+	return len(st.data)
 }
 
 func (st *stack) swap(n int) {
@@ -60,7 +58,7 @@ func (st *stack) swap(n int) {
 }
 
 func (st *stack) dup(n int) {
-	st.push(st.data[st.len()-n])
+	st.push(new(big.Int).Set(st.data[st.len()-n]))
 }
 
 func (st *stack) peek() *big.Int {

core/vm/vm.go

@@ -24,30 +24,19 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/state"
 	"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"
 )
 
 // Vm implements VirtualMachine
 type Vm struct {
 	env Environment
-
-	err error
-	// For logging
-	debug bool
-
-	BreakPoints []int64
-	Stepping    bool
-	Fn          string
-
-	Recoverable bool
-
-	// Will be called before the vm returns
-	After func(*Context, error)
 }
 
 // New returns a new Virtual Machine
 func New(env Environment) *Vm {
-	return &Vm{env: env, debug: Debug, Recoverable: true}
+	return &Vm{env: env}
 }
 
 // Run loops and evaluates the contract's code with the given input data
@@ -55,6 +44,57 @@ func (self *Vm) Run(context *Context, input []byte) (ret []byte, err error) {
 	self.env.SetDepth(self.env.Depth() + 1)
 	defer self.env.SetDepth(self.env.Depth() - 1)
 
+	// User defer pattern to check for an error and, based on the error being nil or not, use all gas and return.
+	defer func() {
+		if err != nil {
+			// In case of a VM exception (known exceptions) all gas consumed (panics NOT included).
+			context.UseGas(context.Gas)
+
+			ret = context.Return(nil)
+		}
+	}()
+
+	if context.CodeAddr != nil {
+		if p := Precompiled[context.CodeAddr.Str()]; p != nil {
+			return self.RunPrecompiled(p, input, context)
+		}
+	}
+
+	var (
+		codehash = crypto.Sha3Hash(context.Code) // codehash is used when doing jump dest caching
+		program  *Program
+	)
+	if !DisableJit {
+		// Fetch program status.
+		// * If ready run using JIT
+		// * If unknown, compile in a seperate goroutine
+		// * If forced wait for compilation and run once done
+		if status := GetProgramStatus(codehash); status == progReady {
+			return RunProgram(GetProgram(codehash), self.env, context, input)
+		} else if status == progUnknown {
+			if ForceJit {
+				// Create and compile program
+				program = NewProgram(context.Code)
+				perr := CompileProgram(program)
+				if perr == nil {
+					return RunProgram(program, self.env, context, input)
+				}
+				glog.V(logger.Info).Infoln("error compiling program", err)
+			} else {
+				// create and compile the program. Compilation
+				// is done in a seperate goroutine
+				program = NewProgram(context.Code)
+				go func() {
+					err := CompileProgram(program)
+					if err != nil {
+						glog.V(logger.Info).Infoln("error compiling program", err)
+						return
+					}
+				}()
+			}
+		}
+	}
+
 	var (
 		caller = context.caller
 		code   = context.Code
@@ -62,7 +102,6 @@ func (self *Vm) Run(context *Context, input []byte) (ret []byte, err error) {
 		price  = context.Price
 
 		op      OpCode             // current opcode
-		codehash = crypto.Sha3Hash(code) // codehash is used when doing jump dest caching
 		mem     = NewMemory()      // bound memory
 		stack   = newstack()       // local stack
 		statedb = self.env.State() // current state
@@ -89,32 +128,25 @@ func (self *Vm) Run(context *Context, input []byte) (ret []byte, err error) {
 
 	// User defer pattern to check for an error and, based on the error being nil or not, use all gas and return.
 	defer func() {
-		if self.After != nil {
-			self.After(context, err)
-		}
-
 		if err != nil {
 			self.log(pc, op, context.Gas, cost, mem, stack, context, err)
-
-			// In case of a VM exception (known exceptions) all gas consumed (panics NOT included).
-			context.UseGas(context.Gas)
-
-			ret = context.Return(nil)
 		}
 	}()
 
-	if context.CodeAddr != nil {
-		if p := Precompiled[context.CodeAddr.Str()]; p != nil {
-			return self.RunPrecompiled(p, input, context)
-		}
-	}
-
 	// Don't bother with the execution if there's no code.
 	if len(code) == 0 {
 		return context.Return(nil), nil
 	}
 
 	for {
+		// Overhead of the atomic read might not be worth it
+		/* TODO this still causes a few issues in the tests
+		if program != nil && progStatus(atomic.LoadInt32(&program.status)) == progReady {
+			// move execution
+			glog.V(logger.Info).Infoln("Moved execution to JIT")
+			return runProgram(program, pc, mem, stack, self.env, context, input)
+		}
+		*/
 		// The base for all big integer arithmetic
 		base := new(big.Int)
 
@@ -122,7 +154,7 @@ func (self *Vm) Run(context *Context, input []byte) (ret []byte, err error) {
 		op = context.GetOp(pc)
 
 		// calculate the new memory size and gas price for the current executing opcode
-		newMemSize, cost, err = self.calculateGasAndSize(context, caller, op, statedb, mem, stack)
+		newMemSize, cost, err = calculateGasAndSize(self.env, context, caller, op, statedb, mem, stack)
 		if err != nil {
 			return nil, err
 		}
@@ -130,11 +162,9 @@ func (self *Vm) Run(context *Context, input []byte) (ret []byte, err error) {
 		// Use the calculated gas. When insufficient gas is present, use all gas and return an
 		// Out Of Gas error
 		if !context.UseGas(cost) {
-
+			return nil, OutOfGasError
-			context.UseGas(context.Gas)
-
-			return context.Return(nil), OutOfGasError
 		}
+
 		// Resize the memory calculated previously
 		mem.Resize(newMemSize.Uint64())
 		// Add a log message
@@ -376,7 +406,7 @@ func (self *Vm) Run(context *Context, input []byte) (ret []byte, err error) {
 			addr := common.BigToAddress(stack.pop())
 			balance := statedb.GetBalance(addr)
 
-			stack.push(balance)
+			stack.push(new(big.Int).Set(balance))
 
 		case ORIGIN:
 			origin := self.env.Origin()
@@ -388,7 +418,7 @@ func (self *Vm) Run(context *Context, input []byte) (ret []byte, err error) {
 			stack.push(common.Bytes2Big(caller.Bytes()))
 
 		case CALLVALUE:
-			stack.push(value)
+			stack.push(new(big.Int).Set(value))
 
 		case CALLDATALOAD:
 			data := getData(input, stack.pop(), common.Big32)
@@ -441,7 +471,7 @@ func (self *Vm) Run(context *Context, input []byte) (ret []byte, err error) {
 			mem.Set(mOff.Uint64(), l.Uint64(), codeCopy)
 
 		case GASPRICE:
-			stack.push(context.Price)
+			stack.push(new(big.Int).Set(context.Price))
 
 		case BLOCKHASH:
 			num := stack.pop()
@@ -471,11 +501,11 @@ func (self *Vm) Run(context *Context, input []byte) (ret []byte, err error) {
 		case DIFFICULTY:
 			difficulty := self.env.Difficulty()
 
-			stack.push(difficulty)
+			stack.push(new(big.Int).Set(difficulty))
 
 		case GASLIMIT:
 
-			stack.push(self.env.GasLimit())
+			stack.push(new(big.Int).Set(self.env.GasLimit()))
 
 		case PUSH1, PUSH2, PUSH3, PUSH4, PUSH5, PUSH6, PUSH7, PUSH8, PUSH9, PUSH10, PUSH11, PUSH12, PUSH13, PUSH14, PUSH15, PUSH16, PUSH17, PUSH18, PUSH19, PUSH20, PUSH21, PUSH22, PUSH23, PUSH24, PUSH25, PUSH26, PUSH27, PUSH28, PUSH29, PUSH30, PUSH31, PUSH32:
 			size := uint64(op - PUSH1 + 1)
@@ -555,8 +585,7 @@ func (self *Vm) Run(context *Context, input []byte) (ret []byte, err error) {
 		case MSIZE:
 			stack.push(big.NewInt(int64(mem.Len())))
 		case GAS:
-			stack.push(context.Gas)
+			stack.push(new(big.Int).Set(context.Gas))
-
 		case CREATE:
 
 			var (
@@ -652,7 +681,7 @@ func (self *Vm) Run(context *Context, 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 (self *Vm) calculateGasAndSize(context *Context, caller ContextRef, op OpCode, statedb *state.StateDB, mem *Memory, stack *stack) (*big.Int, *big.Int, error) {
+func calculateGasAndSize(env Environment, context *Context, caller ContextRef, op OpCode, statedb *state.StateDB, mem *Memory, stack *stack) (*big.Int, *big.Int, error) {
 	var (
 		gas                 = new(big.Int)
 		newMemSize *big.Int = new(big.Int)
@@ -759,7 +788,7 @@ func (self *Vm) calculateGasAndSize(context *Context, caller ContextRef, op OpCo
 		gas.Add(gas, stack.data[stack.len()-1])
 
 		if op == CALL {
-			if self.env.State().GetStateObject(common.BigToAddress(stack.data[stack.len()-2])) == nil {
+			if env.State().GetStateObject(common.BigToAddress(stack.data[stack.len()-2])) == nil {
 				gas.Add(gas, params.CallNewAccountGas)
 			}
 		}

core/vm_env.go

@@ -69,6 +69,10 @@ func (self *VMEnv) GetHash(n uint64) common.Hash {
 func (self *VMEnv) AddLog(log *state.Log) {
 	self.state.AddLog(log)
 }
+func (self *VMEnv) CanTransfer(from vm.Account, balance *big.Int) bool {
+	return from.Balance().Cmp(balance) >= 0
+}
+
 func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error {
 	return vm.Transfer(from, to, amount)
 }

eth/backend.go

@@ -45,7 +45,7 @@ import (
 	"github.com/ethereum/go-ethereum/p2p"
 	"github.com/ethereum/go-ethereum/p2p/discover"
 	"github.com/ethereum/go-ethereum/p2p/nat"
-	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/trie"
 	"github.com/ethereum/go-ethereum/whisper"
 )
 
@@ -92,6 +92,7 @@ type Config struct {
 	NatSpec   bool
 	AutoDAG   bool
 	PowTest   bool
+	ExtraData []byte
 
 	MaxPeers        int
 	MaxPendingPeers int
@@ -206,9 +207,8 @@ type Ethereum struct {
 	shutdownChan chan bool
 
 	// DB interfaces
-	blockDb common.Database // Block chain database
+	chainDb common.Database // Block chain databe
-	stateDb common.Database // State changes database
+	dappDb  common.Database // Dapp database
-	extraDb common.Database // Extra database (txs, etc)
 
 	// Closed when databases are flushed and closed
 	databasesClosed chan bool
@@ -266,27 +266,27 @@ func New(config *Config) (*Ethereum, error) {
 	if newdb == nil {
 		newdb = func(path string) (common.Database, error) { return ethdb.NewLDBDatabase(path, config.DatabaseCache) }
 	}
-	blockDb, err := newdb(filepath.Join(config.DataDir, "blockchain"))
+
+	// attempt to merge database together, upgrading from an old version
+	if err := mergeDatabases(config.DataDir, newdb); err != nil {
+		return nil, err
+	}
+
+	chainDb, err := newdb(filepath.Join(config.DataDir, "chaindata"))
 	if err != nil {
 		return nil, fmt.Errorf("blockchain db err: %v", err)
 	}
-	if db, ok := blockDb.(*ethdb.LDBDatabase); ok {
+	if db, ok := chainDb.(*ethdb.LDBDatabase); ok {
-		db.Meter("eth/db/block/")
+		db.Meter("eth/db/chaindata/")
 	}
-	stateDb, err := newdb(filepath.Join(config.DataDir, "state"))
+	dappDb, err := newdb(filepath.Join(config.DataDir, "dapp"))
 	if err != nil {
-		return nil, fmt.Errorf("state db err: %v", err)
+		return nil, fmt.Errorf("dapp db err: %v", err)
 	}
-	if db, ok := stateDb.(*ethdb.LDBDatabase); ok {
+	if db, ok := dappDb.(*ethdb.LDBDatabase); ok {
-		db.Meter("eth/db/state/")
+		db.Meter("eth/db/dapp/")
-	}
-	extraDb, err := newdb(filepath.Join(config.DataDir, "extra"))
-	if err != nil {
-		return nil, fmt.Errorf("extra db err: %v", err)
-	}
-	if db, ok := extraDb.(*ethdb.LDBDatabase); ok {
-		db.Meter("eth/db/extra/")
 	}
+
 	nodeDb := filepath.Join(config.DataDir, "nodes")
 	glog.V(logger.Info).Infof("Protocol Versions: %v, Network Id: %v", ProtocolVersions, config.NetworkId)
 
@@ -296,7 +296,7 @@ func New(config *Config) (*Ethereum, error) {
 			return nil, err
 		}
 
-		block, err := core.WriteGenesisBlock(stateDb, blockDb, fr)
+		block, err := core.WriteGenesisBlock(chainDb, fr)
 		if err != nil {
 			return nil, err
 		}
@@ -304,7 +304,7 @@ func New(config *Config) (*Ethereum, error) {
 	}
 
 	if config.Olympic {
-		_, err := core.WriteTestNetGenesisBlock(stateDb, blockDb, 42)
+		_, err := core.WriteTestNetGenesisBlock(chainDb, 42)
 		if err != nil {
 			return nil, err
 		}
@@ -313,26 +313,25 @@ func New(config *Config) (*Ethereum, error) {
 
 	// This is for testing only.
 	if config.GenesisBlock != nil {
-		core.WriteBlock(blockDb, config.GenesisBlock)
+		core.WriteBlock(chainDb, config.GenesisBlock)
-		core.WriteHead(blockDb, config.GenesisBlock)
+		core.WriteHead(chainDb, config.GenesisBlock)
 	}
 
 	if !config.SkipBcVersionCheck {
-		b, _ := blockDb.Get([]byte("BlockchainVersion"))
+		b, _ := chainDb.Get([]byte("BlockchainVersion"))
 		bcVersion := int(common.NewValue(b).Uint())
 		if bcVersion != config.BlockChainVersion && bcVersion != 0 {
 			return nil, fmt.Errorf("Blockchain DB version mismatch (%d / %d). Run geth upgradedb.\n", bcVersion, config.BlockChainVersion)
 		}
-		saveBlockchainVersion(blockDb, config.BlockChainVersion)
+		saveBlockchainVersion(chainDb, config.BlockChainVersion)
 	}
 	glog.V(logger.Info).Infof("Blockchain DB Version: %d", config.BlockChainVersion)
 
 	eth := &Ethereum{
 		shutdownChan:            make(chan bool),
 		databasesClosed:         make(chan bool),
-		blockDb:                 blockDb,
+		chainDb:                 chainDb,
-		stateDb:                 stateDb,
+		dappDb:                  dappDb,
-		extraDb:                 extraDb,
 		eventMux:                &event.TypeMux{},
 		accountManager:          config.AccountManager,
 		DataDir:                 config.DataDir,
@@ -362,7 +361,7 @@ func New(config *Config) (*Ethereum, error) {
 		eth.pow = ethash.New()
 	}
 	//genesis := core.GenesisBlock(uint64(config.GenesisNonce), stateDb)
-	eth.chainManager, err = core.NewChainManager(blockDb, stateDb, extraDb, eth.pow, eth.EventMux())
+	eth.chainManager, err = core.NewChainManager(chainDb, eth.pow, eth.EventMux())
 	if err != nil {
 		if err == core.ErrNoGenesis {
 			return nil, fmt.Errorf(`Genesis block not found. Please supply a genesis block with the "--genesis /path/to/file" argument`)
@@ -372,18 +371,13 @@ func New(config *Config) (*Ethereum, error) {
 	}
 	eth.txPool = core.NewTxPool(eth.EventMux(), eth.chainManager.State, eth.chainManager.GasLimit)
 
-	eth.blockProcessor = core.NewBlockProcessor(stateDb, extraDb, eth.pow, eth.chainManager, eth.EventMux())
+	eth.blockProcessor = core.NewBlockProcessor(chainDb, eth.pow, eth.chainManager, eth.EventMux())
 	eth.chainManager.SetProcessor(eth.blockProcessor)
 	eth.protocolManager = NewProtocolManager(config.NetworkId, eth.eventMux, eth.txPool, eth.pow, eth.chainManager)
 
 	eth.miner = miner.New(eth, eth.EventMux(), eth.pow)
 	eth.miner.SetGasPrice(config.GasPrice)
-
+	eth.miner.SetExtra(config.ExtraData)
-	extra := config.Name
-	if uint64(len(extra)) > params.MaximumExtraDataSize.Uint64() {
-		extra = extra[:params.MaximumExtraDataSize.Uint64()]
-	}
-	eth.miner.SetExtra([]byte(extra))
 
 	if config.Shh {
 		eth.whisper = whisper.New()
@@ -525,9 +519,8 @@ func (s *Ethereum) BlockProcessor() *core.BlockProcessor { return s.blockProcess
 func (s *Ethereum) TxPool() *core.TxPool                 { return s.txPool }
 func (s *Ethereum) Whisper() *whisper.Whisper            { return s.whisper }
 func (s *Ethereum) EventMux() *event.TypeMux             { return s.eventMux }
-func (s *Ethereum) BlockDb() common.Database             { return s.blockDb }
+func (s *Ethereum) ChainDb() common.Database             { return s.chainDb }
-func (s *Ethereum) StateDb() common.Database             { return s.stateDb }
+func (s *Ethereum) DappDb() common.Database              { return s.dappDb }
-func (s *Ethereum) ExtraDb() common.Database             { return s.extraDb }
 func (s *Ethereum) IsListening() bool                    { return true } // Always listening
 func (s *Ethereum) PeerCount() int                       { return s.net.PeerCount() }
 func (s *Ethereum) Peers() []*p2p.Peer                   { return s.net.Peers() }
@@ -574,23 +567,19 @@ done:
 		select {
 		case <-ticker.C:
 			// don't change the order of database flushes
-			if err := s.extraDb.Flush(); err != nil {
+			if err := s.dappDb.Flush(); err != nil {
-				glog.Fatalf("fatal error: flush extraDb: %v (Restart your node. We are aware of this issue)\n", err)
+				glog.Fatalf("fatal error: flush dappDb: %v (Restart your node. We are aware of this issue)\n", err)
 			}
-			if err := s.stateDb.Flush(); err != nil {
+			if err := s.chainDb.Flush(); err != nil {
-				glog.Fatalf("fatal error: flush stateDb: %v (Restart your node. We are aware of this issue)\n", err)
+				glog.Fatalf("fatal error: flush chainDb: %v (Restart your node. We are aware of this issue)\n", err)
-			}
-			if err := s.blockDb.Flush(); err != nil {
-				glog.Fatalf("fatal error: flush blockDb: %v (Restart your node. We are aware of this issue)\n", err)
 			}
 		case <-s.shutdownChan:
 			break done
 		}
 	}
 
-	s.blockDb.Close()
+	s.chainDb.Close()
-	s.stateDb.Close()
+	s.dappDb.Close()
-	s.extraDb.Close()
 
 	close(s.databasesClosed)
 }
@@ -688,14 +677,6 @@ func (self *Ethereum) StartAutoDAG() {
 	}()
 }
 
-// dagFiles(epoch) returns the two alternative DAG filenames (not a path)
-// 1) <revision>-<hex(seedhash[8])> 2) full-R<revision>-<hex(seedhash[8])>
-func dagFiles(epoch uint64) (string, string) {
-	seedHash, _ := ethash.GetSeedHash(epoch * epochLength)
-	dag := fmt.Sprintf("full-R%d-%x", ethashRevision, seedHash[:8])
-	return dag, "full-R" + dag
-}
-
 // stopAutoDAG stops automatic DAG pregeneration by quitting the loop
 func (self *Ethereum) StopAutoDAG() {
 	if self.autodagquit != nil {
@@ -705,30 +686,6 @@ func (self *Ethereum) StopAutoDAG() {
 	glog.V(logger.Info).Infof("Automatic pregeneration of ethash DAG OFF (ethash dir: %s)", ethash.DefaultDir)
 }
 
-/*
-	// The databases were previously tied to protocol versions. Currently we
-	// are moving away from this decision as approaching Frontier. The below
-	// code was left in for now but should eventually be just dropped.
-
-	func saveProtocolVersion(db common.Database, protov int) {
-		d, _ := db.Get([]byte("ProtocolVersion"))
-		protocolVersion := common.NewValue(d).Uint()
-
-		if protocolVersion == 0 {
-			db.Put([]byte("ProtocolVersion"), common.NewValue(protov).Bytes())
-		}
-	}
-*/
-
-func saveBlockchainVersion(db common.Database, bcVersion int) {
-	d, _ := db.Get([]byte("BlockchainVersion"))
-	blockchainVersion := common.NewValue(d).Uint()
-
-	if blockchainVersion == 0 {
-		db.Put([]byte("BlockchainVersion"), common.NewValue(bcVersion).Bytes())
-	}
-}
-
 func (self *Ethereum) Solc() (*compiler.Solidity, error) {
 	var err error
 	if self.solc == nil {
@@ -743,3 +700,87 @@ func (self *Ethereum) SetSolc(solcPath string) (*compiler.Solidity, error) {
 	self.solc = nil
 	return self.Solc()
 }
+
+// dagFiles(epoch) returns the two alternative DAG filenames (not a path)
+// 1) <revision>-<hex(seedhash[8])> 2) full-R<revision>-<hex(seedhash[8])>
+func dagFiles(epoch uint64) (string, string) {
+	seedHash, _ := ethash.GetSeedHash(epoch * epochLength)
+	dag := fmt.Sprintf("full-R%d-%x", ethashRevision, seedHash[:8])
+	return dag, "full-R" + dag
+}
+
+func saveBlockchainVersion(db common.Database, bcVersion int) {
+	d, _ := db.Get([]byte("BlockchainVersion"))
+	blockchainVersion := common.NewValue(d).Uint()
+
+	if blockchainVersion == 0 {
+		db.Put([]byte("BlockchainVersion"), common.NewValue(bcVersion).Bytes())
+	}
+}
+
+// mergeDatabases when required merge old database layout to one single database
+func mergeDatabases(datadir string, newdb func(path string) (common.Database, error)) error {
+	// Check if already upgraded
+	data := filepath.Join(datadir, "chaindata")
+	if _, err := os.Stat(data); !os.IsNotExist(err) {
+		return nil
+	}
+	// make sure it's not just a clean path
+	chainPath := filepath.Join(datadir, "blockchain")
+	if _, err := os.Stat(chainPath); os.IsNotExist(err) {
+		return nil
+	}
+	glog.Infoln("Database upgrade required. Upgrading...")
+
+	database, err := newdb(data)
+	if err != nil {
+		return fmt.Errorf("creating data db err: %v", err)
+	}
+	defer database.Close()
+
+	glog.Infoln("Merging blockchain database...")
+	chainDb, err := newdb(chainPath)
+	if err != nil {
+		return fmt.Errorf("state db err: %v", err)
+	}
+	defer chainDb.Close()
+
+	if db, ok := chainDb.(*ethdb.LDBDatabase); ok {
+		it := db.NewIterator()
+		for it.Next() {
+			database.Put(it.Key(), it.Value())
+		}
+	}
+
+	glog.Infoln("Merging state database...")
+	state := filepath.Join(datadir, "state")
+	stateDb, err := newdb(state)
+	if err != nil {
+		return fmt.Errorf("state db err: %v", err)
+	}
+	defer stateDb.Close()
+
+	if db, ok := chainDb.(*ethdb.LDBDatabase); ok {
+		it := db.NewIterator()
+		for it.Next() {
+			database.Put(append(trie.StatePre, it.Key()...), it.Value())
+		}
+	}
+
+	glog.Infoln("Merging transaction database...")
+	extra := filepath.Join(datadir, "extra")
+	extraDb, err := newdb(extra)
+	if err != nil {
+		return fmt.Errorf("state db err: %v", err)
+	}
+	defer extraDb.Close()
+
+	if db, ok := chainDb.(*ethdb.LDBDatabase); ok {
+		it := db.NewIterator()
+		for it.Next() {
+			database.Put(it.Key(), it.Value())
+		}
+	}
+
+	return nil
+}

eth/protocol_test.go

@@ -179,10 +179,10 @@ type testPeer struct {
 
 func newProtocolManagerForTesting(txAdded chan<- []*types.Transaction) *ProtocolManager {
 	db, _ := ethdb.NewMemDatabase()
-	core.WriteTestNetGenesisBlock(db, db, 0)
+	core.WriteTestNetGenesisBlock(db, 0)
 	var (
 		em       = new(event.TypeMux)
-		chain, _ = core.NewChainManager(db, db, db, core.FakePow{}, em)
+		chain, _ = core.NewChainManager(db, core.FakePow{}, em)
 		txpool   = &fakeTxPool{added: txAdded}
 		pm       = NewProtocolManager(NetworkId, em, txpool, core.FakePow{}, chain)
 	)

ethdb/database.go

@@ -41,9 +41,8 @@ var OpenFileLimit = common.MaxOpenFileLimit()
 // cacheRatio specifies how the total alloted cache is distributed between the
 // various system databases.
 var cacheRatio = map[string]float64{
-	"blockchain": 1.0 / 13.0,
+	"dapp":      2.0 / 13.0,
-	"extra":      2.0 / 13.0,
+	"chaindata": 11.0 / 13.0,
-	"state":      10.0 / 13.0,
 }
 
 type LDBDatabase struct {

jsre/jsre_test.go

@@ -19,6 +19,7 @@ package jsre
 import (
 	"io/ioutil"
 	"os"
+	"path"
 	"testing"
 	"time"
 
@@ -40,10 +41,23 @@ func (no *testNativeObjectBinding) TestMethod(call otto.FunctionCall) otto.Value
 	return v
 }
 
-func TestExec(t *testing.T) {
+func newWithTestJS(t *testing.T, testjs string) (*JSRE, string) {
-	jsre := New("/tmp")
+	dir, err := ioutil.TempDir("", "jsre-test")
+	if err != nil {
+		t.Fatal("cannot create temporary directory:", err)
+	}
+	if testjs != "" {
+		if err := ioutil.WriteFile(path.Join(dir, "test.js"), []byte(testjs), os.ModePerm); err != nil {
+			t.Fatal("cannot create test.js:", err)
+		}
+	}
+	return New(dir), dir
+}
+
+func TestExec(t *testing.T) {
+	jsre, dir := newWithTestJS(t, `msg = "testMsg"`)
+	defer os.RemoveAll(dir)
 
-	ioutil.WriteFile("/tmp/test.js", []byte(`msg = "testMsg"`), os.ModePerm)
 	err := jsre.Exec("test.js")
 	if err != nil {
 		t.Errorf("expected no error, got %v", err)
@@ -64,9 +78,9 @@ func TestExec(t *testing.T) {
 }
 
 func TestNatto(t *testing.T) {
-	jsre := New("/tmp")
+	jsre, dir := newWithTestJS(t, `setTimeout(function(){msg = "testMsg"}, 1);`)
+	defer os.RemoveAll(dir)
 
-	ioutil.WriteFile("/tmp/test.js", []byte(`setTimeout(function(){msg = "testMsg"}, 1);`), os.ModePerm)
 	err := jsre.Exec("test.js")
 	if err != nil {
 		t.Errorf("expected no error, got %v", err)
@@ -88,7 +102,7 @@ func TestNatto(t *testing.T) {
 }
 
 func TestBind(t *testing.T) {
-	jsre := New("/tmp")
+	jsre := New("")
 
 	jsre.Bind("no", &testNativeObjectBinding{})
 
@@ -105,9 +119,9 @@ func TestBind(t *testing.T) {
 }
 
 func TestLoadScript(t *testing.T) {
-	jsre := New("/tmp")
+	jsre, dir := newWithTestJS(t, `msg = "testMsg"`)
+	defer os.RemoveAll(dir)
 
-	ioutil.WriteFile("/tmp/test.js", []byte(`msg = "testMsg"`), os.ModePerm)
 	_, err := jsre.Run(`loadScript("test.js")`)
 	if err != nil {
 		t.Errorf("expected no error, got %v", err)

miner/miner.go

@@ -18,6 +18,7 @@
 package miner
 
 import (
+	"fmt"
 	"math/big"
 	"sync/atomic"
 
@@ -29,6 +30,7 @@ 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"
 	"github.com/ethereum/go-ethereum/pow"
 )
 
@@ -139,12 +141,24 @@ func (self *Miner) Mining() bool {
 	return atomic.LoadInt32(&self.mining) > 0
 }
 
-func (self *Miner) HashRate() int64 {
+func (self *Miner) HashRate() (tot int64) {
-	return self.pow.GetHashrate()
+	tot += self.pow.GetHashrate()
+	// do we care this might race? is it worth we're rewriting some
+	// aspects of the worker/locking up agents so we can get an accurate
+	// hashrate?
+	for _, agent := range self.worker.agents {
+		tot += agent.GetHashRate()
+	}
+	return
 }
 
-func (self *Miner) SetExtra(extra []byte) {
+func (self *Miner) SetExtra(extra []byte) error {
+	if uint64(len(extra)) > params.MaximumExtraDataSize.Uint64() {
+		return fmt.Errorf("Extra exceeds max length. %d > %v", len(extra), params.MaximumExtraDataSize)
+	}
+
 	self.worker.extra = extra
+	return nil
 }
 
 func (self *Miner) PendingState() *state.StateDB {

miner/remote_agent.go

@@ -27,6 +27,11 @@ import (
 	"github.com/ethereum/go-ethereum/logger/glog"
 )
 
+type hashrate struct {
+	ping time.Time
+	rate uint64
+}
+
 type RemoteAgent struct {
 	mu sync.Mutex
 
@@ -36,14 +41,24 @@ type RemoteAgent struct {
 
 	currentWork *Work
 	work        map[common.Hash]*Work
+
+	hashrateMu sync.RWMutex
+	hashrate   map[common.Hash]hashrate
 }
 
 func NewRemoteAgent() *RemoteAgent {
-	agent := &RemoteAgent{work: make(map[common.Hash]*Work)}
+	agent := &RemoteAgent{work: make(map[common.Hash]*Work), hashrate: make(map[common.Hash]hashrate)}
 
 	return agent
 }
 
+func (a *RemoteAgent) SubmitHashrate(id common.Hash, rate uint64) {
+	a.hashrateMu.Lock()
+	defer a.hashrateMu.Unlock()
+
+	a.hashrate[id] = hashrate{time.Now(), rate}
+}
+
 func (a *RemoteAgent) Work() chan<- *Work {
 	return a.workCh
 }
@@ -63,7 +78,17 @@ func (a *RemoteAgent) Stop() {
 	close(a.workCh)
 }
 
-func (a *RemoteAgent) GetHashRate() int64 { return 0 }
+// GetHashRate returns the accumulated hashrate of all identifier combined
+func (a *RemoteAgent) GetHashRate() (tot int64) {
+	a.hashrateMu.RLock()
+	defer a.hashrateMu.RUnlock()
+
+	// this could overflow
+	for _, hashrate := range a.hashrate {
+		tot += int64(hashrate.rate)
+	}
+	return
+}
 
 func (a *RemoteAgent) GetWork() [3]string {
 	a.mu.Lock()
@@ -131,6 +156,14 @@ out:
 				}
 			}
 			a.mu.Unlock()
+
+			a.hashrateMu.Lock()
+			for id, hashrate := range a.hashrate {
+				if time.Since(hashrate.ping) > 10*time.Second {
+					delete(a.hashrate, id)
+				}
+			}
+			a.hashrateMu.Unlock()
 		}
 	}
 }

miner/worker.go

@@ -100,7 +100,7 @@ type worker struct {
 	eth     core.Backend
 	chain   *core.ChainManager
 	proc    *core.BlockProcessor
-	extraDb common.Database
+	chainDb common.Database
 
 	coinbase common.Address
 	gasPrice *big.Int
@@ -126,7 +126,7 @@ func newWorker(coinbase common.Address, eth core.Backend) *worker {
 	worker := &worker{
 		eth:            eth,
 		mux:            eth.EventMux(),
-		extraDb:        eth.ExtraDb(),
+		chainDb:        eth.ChainDb(),
 		recv:           make(chan *Result, resultQueueSize),
 		gasPrice:       new(big.Int),
 		chain:          eth.ChainManager(),
@@ -291,9 +291,9 @@ func (self *worker) wait() {
 				// check if canon block and write transactions
 				if stat == core.CanonStatTy {
 					// This puts transactions in a extra db for rpc
-					core.PutTransactions(self.extraDb, block, block.Transactions())
+					core.PutTransactions(self.chainDb, block, block.Transactions())
 					// store the receipts
-					core.PutReceipts(self.extraDb, work.receipts)
+					core.PutReceipts(self.chainDb, work.receipts)
 				}
 
 				// broadcast before waiting for validation
@@ -344,7 +344,7 @@ func (self *worker) push(work *Work) {
 
 // makeCurrent creates a new environment for the current cycle.
 func (self *worker) makeCurrent(parent *types.Block, header *types.Header) {
-	state := state.New(parent.Root(), self.eth.StateDb())
+	state := state.New(parent.Root(), self.eth.ChainDb())
 	work := &Work{
 		state:     state,
 		ancestors: set.New(),

p2p/discover/table.go

@@ -78,9 +78,8 @@ type transport interface {
 	close()
 }
 
-// bucket contains nodes, ordered by their last activity.
+// bucket contains nodes, ordered by their last activity. the entry
-// the entry that was most recently active is the last element
+// that was most recently active is the first element in entries.
-// in entries.
 type bucket struct {
 	lastLookup time.Time
 	entries    []*Node
@@ -164,7 +163,9 @@ func randUint(max uint32) uint32 {
 
 // Close terminates the network listener and flushes the node database.
 func (tab *Table) Close() {
+	if tab.net != nil {
 		tab.net.close()
+	}
 	tab.db.close()
 }
 
@@ -233,7 +234,7 @@ func (tab *Table) Lookup(targetID NodeID) []*Node {
 
 						if fails >= maxFindnodeFailures {
 							glog.V(logger.Detail).Infof("Evacuating node %x: %d findnode failures", n.ID[:8], fails)
-							tab.del(n)
+							tab.delete(n)
 						}
 					}
 					reply <- tab.bondall(r)
@@ -399,15 +400,11 @@ func (tab *Table) bond(pinged bool, id NodeID, addr *net.UDPAddr, tcpPort uint16
 			node = w.n
 		}
 	}
-	// Even if bonding temporarily failed, give the node a chance
 	if node != nil {
-		tab.mutex.Lock()
+		// Add the node to the table even if the bonding ping/pong
-		defer tab.mutex.Unlock()
+		// fails. It will be relaced quickly if it continues to be
-
+		// unresponsive.
-		b := tab.buckets[logdist(tab.self.sha, node.sha)]
+		tab.add(node)
-		if !b.bump(node) {
-			tab.pingreplace(node, b)
-		}
 		tab.db.updateFindFails(id, 0)
 	}
 	return node, result
@@ -418,7 +415,7 @@ func (tab *Table) pingpong(w *bondproc, pinged bool, id NodeID, addr *net.UDPAdd
 	<-tab.bondslots
 	defer func() { tab.bondslots <- struct{}{} }()
 
-	// Ping the remote side and wait for a pong
+	// Ping the remote side and wait for a pong.
 	if w.err = tab.ping(id, addr); w.err != nil {
 		close(w.done)
 		return
@@ -429,33 +426,14 @@ func (tab *Table) pingpong(w *bondproc, pinged bool, id NodeID, addr *net.UDPAdd
 		// waitping will simply time out.
 		tab.net.waitping(id)
 	}
-	// Bonding succeeded, update the node database
+	// Bonding succeeded, update the node database.
 	w.n = newNode(id, addr.IP, uint16(addr.Port), tcpPort)
 	tab.db.updateNode(w.n)
 	close(w.done)
 }
 
-func (tab *Table) pingreplace(new *Node, b *bucket) {
+// ping a remote endpoint and wait for a reply, also updating the node
-	if len(b.entries) == bucketSize {
+// database accordingly.
-		oldest := b.entries[bucketSize-1]
-		if err := tab.ping(oldest.ID, oldest.addr()); err == nil {
-			// The node responded, we don't need to replace it.
-			return
-		}
-	} else {
-		// Add a slot at the end so the last entry doesn't
-		// fall off when adding the new node.
-		b.entries = append(b.entries, nil)
-	}
-	copy(b.entries[1:], b.entries)
-	b.entries[0] = new
-	if tab.nodeAddedHook != nil {
-		tab.nodeAddedHook(new)
-	}
-}
-
-// ping a remote endpoint and wait for a reply, also updating the node database
-// accordingly.
 func (tab *Table) ping(id NodeID, addr *net.UDPAddr) error {
 	// Update the last ping and send the message
 	tab.db.updateLastPing(id, time.Now())
@@ -465,24 +443,53 @@ func (tab *Table) ping(id NodeID, addr *net.UDPAddr) error {
 	// Pong received, update the database and return
 	tab.db.updateLastPong(id, time.Now())
 	tab.db.ensureExpirer()
-
 	return nil
 }
 
-// add puts the entries into the table if their corresponding
+// add attempts to add the given node its corresponding bucket. If the
-// bucket is not full. The caller must hold tab.mutex.
+// bucket has space available, adding the node succeeds immediately.
-func (tab *Table) add(entries []*Node) {
+// Otherwise, the node is added if the least recently active node in
+// the bucket does not respond to a ping packet.
+//
+// The caller must not hold tab.mutex.
+func (tab *Table) add(new *Node) {
+	b := tab.buckets[logdist(tab.self.sha, new.sha)]
+	tab.mutex.Lock()
+	if b.bump(new) {
+		tab.mutex.Unlock()
+		return
+	}
+	var oldest *Node
+	if len(b.entries) == bucketSize {
+		oldest = b.entries[bucketSize-1]
+		// Let go of the mutex so other goroutines can access
+		// the table while we ping the least recently active node.
+		tab.mutex.Unlock()
+		if err := tab.ping(oldest.ID, oldest.addr()); err == nil {
+			// The node responded, don't replace it.
+			return
+		}
+		tab.mutex.Lock()
+	}
+	added := b.replace(new, oldest)
+	tab.mutex.Unlock()
+	if added && tab.nodeAddedHook != nil {
+		tab.nodeAddedHook(new)
+	}
+}
+
+// stuff adds nodes the table to the end of their corresponding bucket
+// if the bucket is not full. The caller must hold tab.mutex.
+func (tab *Table) stuff(nodes []*Node) {
 outer:
-	for _, n := range entries {
+	for _, n := range nodes {
 		if n.ID == tab.self.ID {
-			// don't add self.
+			continue // don't add self
-			continue
 		}
 		bucket := tab.buckets[logdist(tab.self.sha, n.sha)]
 		for i := range bucket.entries {
 			if bucket.entries[i].ID == n.ID {
-				// already in bucket
+				continue outer // already in bucket
-				continue outer
 			}
 		}
 		if len(bucket.entries) < bucketSize {
@@ -494,12 +501,11 @@ outer:
 	}
 }
 
-// del removes an entry from the node table (used to evacuate failed/non-bonded
+// delete removes an entry from the node table (used to evacuate
-// discovery peers).
+// failed/non-bonded discovery peers).
-func (tab *Table) del(node *Node) {
+func (tab *Table) delete(node *Node) {
 	tab.mutex.Lock()
 	defer tab.mutex.Unlock()
-
 	bucket := tab.buckets[logdist(tab.self.sha, node.sha)]
 	for i := range bucket.entries {
 		if bucket.entries[i].ID == node.ID {
@@ -509,6 +515,27 @@ func (tab *Table) del(node *Node) {
 	}
 }
 
+func (b *bucket) replace(n *Node, last *Node) bool {
+	// Don't add if b already contains n.
+	for i := range b.entries {
+		if b.entries[i].ID == n.ID {
+			return false
+		}
+	}
+	// Replace last if it is still the last entry or just add n if b
+	// isn't full. If is no longer the last entry, it has either been
+	// replaced with someone else or became active.
+	if len(b.entries) == bucketSize && (last == nil || b.entries[bucketSize-1].ID != last.ID) {
+		return false
+	}
+	if len(b.entries) < bucketSize {
+		b.entries = append(b.entries, nil)
+	}
+	copy(b.entries[1:], b.entries)
+	b.entries[0] = n
+	return true
+}
+
 func (b *bucket) bump(n *Node) bool {
 	for i := range b.entries {
 		if b.entries[i].ID == n.ID {

p2p/discover/table_test.go

@@ -35,6 +35,7 @@ func TestTable_pingReplace(t *testing.T) {
 	doit := func(newNodeIsResponding, lastInBucketIsResponding bool) {
 		transport := newPingRecorder()
 		tab := newTable(transport, NodeID{}, &net.UDPAddr{}, "")
+		defer tab.Close()
 		pingSender := newNode(MustHexID("a502af0f59b2aab7746995408c79e9ca312d2793cc997e44fc55eda62f0150bbb8c59a6f9269ba3a081518b62699ee807c7c19c20125ddfccca872608af9e370"), net.IP{}, 99, 99)
 
 		// fill up the sender's bucket.
@@ -158,9 +159,7 @@ func newPingRecorder() *pingRecorder {
 func (t *pingRecorder) findnode(toid NodeID, toaddr *net.UDPAddr, target NodeID) ([]*Node, error) {
 	panic("findnode called on pingRecorder")
 }
-func (t *pingRecorder) close() {
+func (t *pingRecorder) close() {}
-	panic("close called on pingRecorder")
-}
 func (t *pingRecorder) waitping(from NodeID) error {
 	return nil // remote always pings
 }
@@ -179,7 +178,8 @@ func TestTable_closest(t *testing.T) {
 	test := func(test *closeTest) bool {
 		// for any node table, Target and N
 		tab := newTable(nil, test.Self, &net.UDPAddr{}, "")
-		tab.add(test.All)
+		defer tab.Close()
+		tab.stuff(test.All)
 
 		// check that doClosest(Target, N) returns nodes
 		result := tab.closest(test.Target, test.N).entries
@@ -237,9 +237,10 @@ func TestTable_ReadRandomNodesGetAll(t *testing.T) {
 	}
 	test := func(buf []*Node) bool {
 		tab := newTable(nil, NodeID{}, &net.UDPAddr{}, "")
+		defer tab.Close()
 		for i := 0; i < len(buf); i++ {
 			ld := cfg.Rand.Intn(len(tab.buckets))
-			tab.add([]*Node{nodeAtDistance(tab.self.sha, ld)})
+			tab.stuff([]*Node{nodeAtDistance(tab.self.sha, ld)})
 		}
 		gotN := tab.ReadRandomNodes(buf)
 		if gotN != tab.len() {
@@ -279,6 +280,7 @@ func (*closeTest) Generate(rand *rand.Rand, size int) reflect.Value {
 func TestTable_Lookup(t *testing.T) {
 	self := nodeAtDistance(common.Hash{}, 0)
 	tab := newTable(lookupTestnet, self.ID, &net.UDPAddr{}, "")
+	defer tab.Close()
 
 	// lookup on empty table returns no nodes
 	if results := tab.Lookup(lookupTestnet.target); len(results) > 0 {
@@ -286,7 +288,7 @@ func TestTable_Lookup(t *testing.T) {
 	}
 	// seed table with initial node (otherwise lookup will terminate immediately)
 	seed := newNode(lookupTestnet.dists[256][0], net.IP{}, 256, 0)
-	tab.add([]*Node{seed})
+	tab.stuff([]*Node{seed})
 
 	results := tab.Lookup(lookupTestnet.target)
 	t.Logf("results:")

p2p/discover/udp.go

@@ -18,6 +18,7 @@ package discover
 
 import (
 	"bytes"
+	"container/list"
 	"crypto/ecdsa"
 	"errors"
 	"fmt"
@@ -43,6 +44,7 @@ var (
 	errUnsolicitedReply = errors.New("unsolicited reply")
 	errUnknownNode      = errors.New("unknown node")
 	errTimeout          = errors.New("RPC timeout")
+	errClockWarp        = errors.New("reply deadline too far in the future")
 	errClosed           = errors.New("socket closed")
 )
 
@@ -296,7 +298,7 @@ func (t *udp) pending(id NodeID, ptype byte, callback func(interface{}) bool) <-
 }
 
 func (t *udp) handleReply(from NodeID, ptype byte, req packet) bool {
-	matched := make(chan bool)
+	matched := make(chan bool, 1)
 	select {
 	case t.gotreply <- reply{from, ptype, req, matched}:
 		// loop will handle it
@@ -310,68 +312,82 @@ func (t *udp) handleReply(from NodeID, ptype byte, req packet) bool {
 // the refresh timer and the pending reply queue.
 func (t *udp) loop() {
 	var (
-		pending      []*pending
+		plist       = list.New()
-		nextDeadline time.Time
 		timeout     = time.NewTimer(0)
+		nextTimeout *pending // head of plist when timeout was last reset
 		refresh     = time.NewTicker(refreshInterval)
 	)
 	<-timeout.C // ignore first timeout
 	defer refresh.Stop()
 	defer timeout.Stop()
 
-	rearmTimeout := func() {
+	resetTimeout := func() {
-		now := time.Now()
+		if plist.Front() == nil || nextTimeout == plist.Front().Value {
-		if len(pending) == 0 || now.Before(nextDeadline) {
 			return
 		}
-		nextDeadline = pending[0].deadline
+		// Start the timer so it fires when the next pending reply has expired.
-		timeout.Reset(nextDeadline.Sub(now))
+		now := time.Now()
+		for el := plist.Front(); el != nil; el = el.Next() {
+			nextTimeout = el.Value.(*pending)
+			if dist := nextTimeout.deadline.Sub(now); dist < 2*respTimeout {
+				timeout.Reset(dist)
+				return
+			}
+			// Remove pending replies whose deadline is too far in the
+			// future. These can occur if the system clock jumped
+			// backwards after the deadline was assigned.
+			nextTimeout.errc <- errClockWarp
+			plist.Remove(el)
+		}
+		nextTimeout = nil
+		timeout.Stop()
 	}
 
 	for {
+		resetTimeout()
+
 		select {
 		case <-refresh.C:
 			go t.refresh()
 
 		case <-t.closing:
-			for _, p := range pending {
+			for el := plist.Front(); el != nil; el = el.Next() {
-				p.errc <- errClosed
+				el.Value.(*pending).errc <- errClosed
 			}
-			pending = nil
 			return
 
 		case p := <-t.addpending:
 			p.deadline = time.Now().Add(respTimeout)
-			pending = append(pending, p)
+			plist.PushBack(p)
-			rearmTimeout()
 
 		case r := <-t.gotreply:
 			var matched bool
-			for i := 0; i < len(pending); i++ {
+			for el := plist.Front(); el != nil; el = el.Next() {
-				if p := pending[i]; p.from == r.from && p.ptype == r.ptype {
+				p := el.Value.(*pending)
+				if p.from == r.from && p.ptype == r.ptype {
 					matched = true
+					// Remove the matcher if its callback indicates
+					// that all replies have been received. This is
+					// required for packet types that expect multiple
+					// reply packets.
 					if p.callback(r.data) {
-						// callback indicates the request is done, remove it.
 						p.errc <- nil
-						copy(pending[i:], pending[i+1:])
+						plist.Remove(el)
-						pending = pending[:len(pending)-1]
-						i--
 					}
 				}
 			}
 			r.matched <- matched
 
 		case now := <-timeout.C:
-			// notify and remove callbacks whose deadline is in the past.
+			nextTimeout = nil
-			i := 0
+			// Notify and remove callbacks whose deadline is in the past.
-			for ; i < len(pending) && now.After(pending[i].deadline); i++ {
+			for el := plist.Front(); el != nil; el = el.Next() {
-				pending[i].errc <- errTimeout
+				p := el.Value.(*pending)
+				if now.After(p.deadline) || now.Equal(p.deadline) {
+					p.errc <- errTimeout
+					plist.Remove(el)
 				}
-			if i > 0 {
-				copy(pending, pending[i:])
-				pending = pending[:len(pending)-i]
 			}
-			rearmTimeout()
 		}
 	}
 }
@@ -385,7 +401,7 @@ const (
 var (
 	headSpace = make([]byte, headSize)
 
-	// Neighbors responses are sent across multiple packets to
+	// Neighbors replies are sent across multiple packets to
 	// stay below the 1280 byte limit. We compute the maximum number
 	// of entries by stuffing a packet until it grows too large.
 	maxNeighbors int

p2p/discover/udp_test.go

@@ -19,10 +19,12 @@ package discover
 import (
 	"bytes"
 	"crypto/ecdsa"
+	"encoding/binary"
 	"errors"
 	"fmt"
 	"io"
 	logpkg "log"
+	"math/rand"
 	"net"
 	"os"
 	"path/filepath"
@@ -138,6 +140,77 @@ func TestUDP_pingTimeout(t *testing.T) {
 	}
 }
 
+func TestUDP_responseTimeouts(t *testing.T) {
+	t.Parallel()
+	test := newUDPTest(t)
+	defer test.table.Close()
+
+	rand.Seed(time.Now().UnixNano())
+	randomDuration := func(max time.Duration) time.Duration {
+		return time.Duration(rand.Int63n(int64(max)))
+	}
+
+	var (
+		nReqs      = 200
+		nTimeouts  = 0                       // number of requests with ptype > 128
+		nilErr     = make(chan error, nReqs) // for requests that get a reply
+		timeoutErr = make(chan error, nReqs) // for requests that time out
+	)
+	for i := 0; i < nReqs; i++ {
+		// Create a matcher for a random request in udp.loop. Requests
+		// with ptype <= 128 will not get a reply and should time out.
+		// For all other requests, a reply is scheduled to arrive
+		// within the timeout window.
+		p := &pending{
+			ptype:    byte(rand.Intn(255)),
+			callback: func(interface{}) bool { return true },
+		}
+		binary.BigEndian.PutUint64(p.from[:], uint64(i))
+		if p.ptype <= 128 {
+			p.errc = timeoutErr
+			nTimeouts++
+		} else {
+			p.errc = nilErr
+			time.AfterFunc(randomDuration(60*time.Millisecond), func() {
+				if !test.udp.handleReply(p.from, p.ptype, nil) {
+					t.Logf("not matched: %v", p)
+				}
+			})
+		}
+		test.udp.addpending <- p
+		time.Sleep(randomDuration(30 * time.Millisecond))
+	}
+
+	// Check that all timeouts were delivered and that the rest got nil errors.
+	// The replies must be delivered.
+	var (
+		recvDeadline        = time.After(20 * time.Second)
+		nTimeoutsRecv, nNil = 0, 0
+	)
+	for i := 0; i < nReqs; i++ {
+		select {
+		case err := <-timeoutErr:
+			if err != errTimeout {
+				t.Fatalf("got non-timeout error on timeoutErr %d: %v", i, err)
+			}
+			nTimeoutsRecv++
+		case err := <-nilErr:
+			if err != nil {
+				t.Fatalf("got non-nil error on nilErr %d: %v", i, err)
+			}
+			nNil++
+		case <-recvDeadline:
+			t.Fatalf("exceeded recv deadline")
+		}
+	}
+	if nTimeoutsRecv != nTimeouts {
+		t.Errorf("wrong number of timeout errors received: got %d, want %d", nTimeoutsRecv, nTimeouts)
+	}
+	if nNil != nReqs-nTimeouts {
+		t.Errorf("wrong number of successful replies: got %d, want %d", nNil, nReqs-nTimeouts)
+	}
+}
+
 func TestUDP_findnodeTimeout(t *testing.T) {
 	t.Parallel()
 	test := newUDPTest(t)
@@ -167,7 +240,7 @@ func TestUDP_findnode(t *testing.T) {
 	for i := 0; i < bucketSize; i++ {
 		nodes.push(nodeAtDistance(test.table.self.sha, i+2), bucketSize)
 	}
-	test.table.add(nodes.entries)
+	test.table.stuff(nodes.entries)
 
 	// ensure there's a bond with the test node,
 	// findnode won't be accepted otherwise.

p2p/nat/natupnp_test.go

@@ -21,6 +21,7 @@ import (
 	"io"
 	"net"
 	"net/http"
+	"runtime"
 	"strings"
 	"testing"
 
@@ -28,6 +29,10 @@ import (
 )
 
 func TestUPNP_DDWRT(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skipf("disabled to avoid firewall prompt")
+	}
+
 	dev := &fakeIGD{
 		t: t,
 		ssdpResp: "HTTP/1.1 200 OK\r\n" +

rpc/api/debug.go

@@ -119,7 +119,7 @@ func (self *debugApi) DumpBlock(req *shared.Request) (interface{}, error) {
 		return nil, fmt.Errorf("block #%d not found", args.BlockNumber)
 	}
 
-	stateDb := state.New(block.Root(), self.ethereum.StateDb())
+	stateDb := state.New(block.Root(), self.ethereum.ChainDb())
 	if stateDb == nil {
 		return nil, nil
 	}

rpc/api/eth.go

@@ -92,6 +92,7 @@ var (
 		"eth_hashrate":                            (*ethApi).Hashrate,
 		"eth_getWork":                             (*ethApi).GetWork,
 		"eth_submitWork":                          (*ethApi).SubmitWork,
+		"eth_submitHashrate":                      (*ethApi).SubmitHashrate,
 		"eth_resend":                              (*ethApi).Resend,
 		"eth_pendingTransactions":                 (*ethApi).PendingTransactions,
 		"eth_getTransactionReceipt":               (*ethApi).GetTransactionReceipt,
@@ -573,6 +574,15 @@ func (self *ethApi) SubmitWork(req *shared.Request) (interface{}, error) {
 	return self.xeth.RemoteMining().SubmitWork(args.Nonce, common.HexToHash(args.Digest), common.HexToHash(args.Header)), nil
 }
 
+func (self *ethApi) SubmitHashrate(req *shared.Request) (interface{}, error) {
+	args := new(SubmitHashRateArgs)
+	if err := self.codec.Decode(req.Params, &args); err != nil {
+		return nil, shared.NewDecodeParamError(err.Error())
+	}
+	self.xeth.RemoteMining().SubmitHashrate(common.HexToHash(args.Id), args.Rate)
+	return nil, nil
+}
+
 func (self *ethApi) Resend(req *shared.Request) (interface{}, error) {
 	args := new(ResendArgs)
 	if err := self.codec.Decode(req.Params, &args); err != nil {

rpc/api/eth_args.go

@@ -169,6 +169,37 @@ func (args *GetTxCountArgs) UnmarshalJSON(b []byte) (err error) {
 	return nil
 }
 
+type SubmitHashRateArgs struct {
+	Id   string
+	Rate uint64
+}
+
+func (args *SubmitHashRateArgs) UnmarshalJSON(b []byte) (err error) {
+	var obj []interface{}
+	if err := json.Unmarshal(b, &obj); err != nil {
+		return shared.NewDecodeParamError(err.Error())
+	}
+
+	if len(obj) < 2 {
+		return shared.NewInsufficientParamsError(len(obj), 2)
+	}
+
+	arg0, ok := obj[0].(string)
+	if !ok {
+		return shared.NewInvalidTypeError("hash", "not a string")
+	}
+	args.Id = arg0
+
+	arg1, ok := obj[1].(string)
+	if !ok {
+		return shared.NewInvalidTypeError("rate", "not a string")
+	}
+
+	args.Rate = common.String2Big(arg1).Uint64()
+
+	return nil
+}
+
 type HashArgs struct {
 	Hash string
 }

rpc/api/miner.go

@@ -17,12 +17,9 @@
 package api
 
 import (
-	"fmt"
-
 	"github.com/ethereum/ethash"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/eth"
-	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rpc/codec"
 	"github.com/ethereum/go-ethereum/rpc/shared"
 )
@@ -126,11 +123,10 @@ func (self *minerApi) SetExtra(req *shared.Request) (interface{}, error) {
 		return nil, err
 	}
 
-	if uint64(len(args.Data)) > params.MaximumExtraDataSize.Uint64()*2 {
+	if err := self.ethereum.Miner().SetExtra([]byte(args.Data)); err != nil {
-		return false, fmt.Errorf("extra datasize can be no longer than %v bytes", params.MaximumExtraDataSize)
+		return false, err
 	}
 
-	self.ethereum.Miner().SetExtra([]byte(args.Data))
 	return true, nil
 }
 

tests/block_test_util.go

@@ -204,7 +204,7 @@ func (test *BlockTest) makeEthConfig() *eth.Config {
 // InsertPreState populates the given database with the genesis
 // accounts defined by the test.
 func (t *BlockTest) InsertPreState(ethereum *eth.Ethereum) (*state.StateDB, error) {
-	db := ethereum.StateDb()
+	db := ethereum.ChainDb()
 	statedb := state.New(common.Hash{}, db)
 	for addrString, acct := range t.preAccounts {
 		addr, err := hex.DecodeString(addrString)

tests/state_test.go

@@ -20,8 +20,25 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
+
+	"github.com/ethereum/go-ethereum/core/vm"
 )
 
+func init() {
+	if os.Getenv("JITVM") == "true" {
+		vm.ForceJit = true
+	} else {
+		vm.DisableJit = true
+	}
+}
+
+func BenchmarkStateCall1024(b *testing.B) {
+	fn := filepath.Join(stateTestDir, "stCallCreateCallCodeTest.json")
+	if err := BenchVmTest(fn, bconf{"Call1024BalanceTooLow", true, false}, b); err != nil {
+		b.Error(err)
+	}
+}
+
 func TestStateSystemOperations(t *testing.T) {
 	fn := filepath.Join(stateTestDir, "stSystemOperationsTest.json")
 	if err := RunStateTest(fn, StateSkipTests); err != nil {

tests/state_test_util.go

@@ -23,6 +23,7 @@ import (
 	"io"
 	"math/big"
 	"strconv"
+	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
@@ -60,6 +61,61 @@ func RunStateTest(p string, skipTests []string) error {
 
 }
 
+func BenchStateTest(p string, conf bconf, b *testing.B) error {
+	tests := make(map[string]VmTest)
+	if err := readJsonFile(p, &tests); err != nil {
+		return err
+	}
+	test, ok := tests[conf.name]
+	if !ok {
+		return fmt.Errorf("test not found: %s", conf.name)
+	}
+
+	pNoJit := vm.DisableJit
+	vm.DisableJit = conf.nojit
+	pForceJit := vm.ForceJit
+	vm.ForceJit = conf.precomp
+
+	// XXX Yeah, yeah...
+	env := make(map[string]string)
+	env["currentCoinbase"] = test.Env.CurrentCoinbase
+	env["currentDifficulty"] = test.Env.CurrentDifficulty
+	env["currentGasLimit"] = test.Env.CurrentGasLimit
+	env["currentNumber"] = test.Env.CurrentNumber
+	env["previousHash"] = test.Env.PreviousHash
+	if n, ok := test.Env.CurrentTimestamp.(float64); ok {
+		env["currentTimestamp"] = strconv.Itoa(int(n))
+	} else {
+		env["currentTimestamp"] = test.Env.CurrentTimestamp.(string)
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		benchStateTest(test, env, b)
+	}
+
+	vm.DisableJit = pNoJit
+	vm.ForceJit = pForceJit
+
+	return nil
+}
+
+func benchStateTest(test VmTest, env map[string]string, b *testing.B) {
+	b.StopTimer()
+	db, _ := ethdb.NewMemDatabase()
+	statedb := state.New(common.Hash{}, db)
+	for addr, account := range test.Pre {
+		obj := StateObjectFromAccount(db, addr, account)
+		statedb.SetStateObject(obj)
+		for a, v := range account.Storage {
+			obj.SetState(common.HexToHash(a), common.HexToHash(v))
+		}
+	}
+	b.StartTimer()
+
+	RunState(statedb, env, test.Exec)
+}
+
 func runStateTests(tests map[string]VmTest, skipTests []string) error {
 	skipTest := make(map[string]bool, len(skipTests))
 	for _, name := range skipTests {

tests/util.go

@@ -18,7 +18,6 @@ package tests
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"math/big"
 
@@ -192,18 +191,19 @@ func (self *Env) AddLog(log *state.Log) {
 }
 func (self *Env) Depth() int     { return self.depth }
 func (self *Env) SetDepth(i int) { self.depth = i }
-func (self *Env) Transfer(from, to vm.Account, amount *big.Int) error {
+func (self *Env) CanTransfer(from vm.Account, balance *big.Int) bool {
 	if self.skipTransfer {
-		// ugly hack
 		if self.initial {
 			self.initial = false
-			return nil
+			return true
+		}
 	}
 
-		if from.Balance().Cmp(amount) < 0 {
+	return from.Balance().Cmp(balance) >= 0
-			return errors.New("Insufficient balance in account")
+}
-		}
 
+func (self *Env) Transfer(from, to vm.Account, amount *big.Int) error {
+	if self.skipTransfer {
 		return nil
 	}
 	return vm.Transfer(from, to, amount)

tests/vm_test.go

@@ -21,6 +21,20 @@ import (
 	"testing"
 )
 
+func BenchmarkVmAckermann32Tests(b *testing.B) {
+	fn := filepath.Join(vmTestDir, "vmPerformanceTest.json")
+	if err := BenchVmTest(fn, bconf{"ackermann32", true, false}, b); err != nil {
+		b.Error(err)
+	}
+}
+
+func BenchmarkVmFibonacci16Tests(b *testing.B) {
+	fn := filepath.Join(vmTestDir, "vmPerformanceTest.json")
+	if err := BenchVmTest(fn, bconf{"fibonacci16", true, false}, b); err != nil {
+		b.Error(err)
+	}
+}
+
 // I've created a new function for each tests so it's easier to identify where the problem lies if any of them fail.
 func TestVMArithmetic(t *testing.T) {
 	fn := filepath.Join(vmTestDir, "vmArithmeticTest.json")

tests/vm_test_util.go

@@ -22,6 +22,7 @@ import (
 	"io"
 	"math/big"
 	"strconv"
+	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/state"
@@ -48,8 +49,79 @@ func RunVmTestWithReader(r io.Reader, skipTests []string) error {
 	return nil
 }
 
-func RunVmTest(p string, skipTests []string) error {
+type bconf struct {
+	name    string
+	precomp bool
+	nojit   bool
+}
 
+func BenchVmTest(p string, conf bconf, b *testing.B) error {
+	tests := make(map[string]VmTest)
+	err := readJsonFile(p, &tests)
+	if err != nil {
+		return err
+	}
+
+	test, ok := tests[conf.name]
+	if !ok {
+		return fmt.Errorf("test not found: %s", conf.name)
+	}
+
+	pNoJit := vm.DisableJit
+	vm.DisableJit = conf.nojit
+	pForceJit := vm.ForceJit
+	vm.ForceJit = conf.precomp
+
+	env := make(map[string]string)
+	env["currentCoinbase"] = test.Env.CurrentCoinbase
+	env["currentDifficulty"] = test.Env.CurrentDifficulty
+	env["currentGasLimit"] = test.Env.CurrentGasLimit
+	env["currentNumber"] = test.Env.CurrentNumber
+	env["previousHash"] = test.Env.PreviousHash
+	if n, ok := test.Env.CurrentTimestamp.(float64); ok {
+		env["currentTimestamp"] = strconv.Itoa(int(n))
+	} else {
+		env["currentTimestamp"] = test.Env.CurrentTimestamp.(string)
+	}
+
+	/*
+		if conf.precomp {
+			program := vm.NewProgram(test.code)
+			err := vm.AttachProgram(program)
+			if err != nil {
+				return err
+			}
+		}
+	*/
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		benchVmTest(test, env, b)
+	}
+
+	vm.DisableJit = pNoJit
+	vm.ForceJit = pForceJit
+
+	return nil
+}
+
+func benchVmTest(test VmTest, env map[string]string, b *testing.B) {
+	b.StopTimer()
+	db, _ := ethdb.NewMemDatabase()
+	statedb := state.New(common.Hash{}, db)
+	for addr, account := range test.Pre {
+		obj := StateObjectFromAccount(db, addr, account)
+		statedb.SetStateObject(obj)
+		for a, v := range account.Storage {
+			obj.SetState(common.HexToHash(a), common.HexToHash(v))
+		}
+	}
+	b.StartTimer()
+
+	RunVm(statedb, env, test.Exec)
+}
+
+func RunVmTest(p string, skipTests []string) error {
 	tests := make(map[string]VmTest)
 	err := readJsonFile(p, &tests)
 	if err != nil {

trie/cache.go

@@ -38,6 +38,8 @@ func NewCache(backend Backend) *Cache {
 }
 
 func (self *Cache) Get(key []byte) []byte {
+	key = append(StatePre, key...)
+
 	data := self.store[string(key)]
 	if data == nil {
 		data, _ = self.backend.Get(key)
@@ -47,8 +49,8 @@ func (self *Cache) Get(key []byte) []byte {
 }
 
 func (self *Cache) Put(key []byte, data []byte) {
-	// write the data to the ldb batch
+	key = append(StatePre, key...)
-	//self.batch.Put(key, rle.Compress(data))
+
 	self.batch.Put(key, data)
 	self.store[string(key)] = data
 }

trie/encoding.go

@@ -16,13 +16,7 @@
 
 package trie
 
-import (
+func CompactEncode(hexSlice []byte) []byte {
-	"bytes"
-	"encoding/hex"
-	"strings"
-)
-
-func CompactEncode(hexSlice []byte) string {
 	terminator := 0
 	if hexSlice[len(hexSlice)-1] == 16 {
 		terminator = 1
@@ -40,15 +34,15 @@ func CompactEncode(hexSlice []byte) string {
 		hexSlice = append([]byte{flags, 0}, hexSlice...)
 	}
 
-	var buff bytes.Buffer
+	l := len(hexSlice) / 2
-	for i := 0; i < len(hexSlice); i += 2 {
+	var buf = make([]byte, l)
-		buff.WriteByte(byte(16*hexSlice[i] + hexSlice[i+1]))
+	for i := 0; i < l; i++ {
+		buf[i] = 16*hexSlice[2*i] + hexSlice[2*i+1]
 	}
-
+	return buf
-	return buff.String()
 }
 
-func CompactDecode(str string) []byte {
+func CompactDecode(str []byte) []byte {
 	base := CompactHexDecode(str)
 	base = base[:len(base)-1]
 	if base[0] >= 2 {
@@ -63,30 +57,23 @@ func CompactDecode(str string) []byte {
 	return base
 }
 
-func CompactHexDecode(str string) []byte {
+func CompactHexDecode(str []byte) []byte {
-	base := "0123456789abcdef"
+	l := len(str)*2 + 1
-	var hexSlice []byte
+	var nibbles = make([]byte, l)
-
+	for i, b := range str {
-	enc := hex.EncodeToString([]byte(str))
+		nibbles[i*2] = b / 16
-	for _, v := range enc {
+		nibbles[i*2+1] = b % 16
-		hexSlice = append(hexSlice, byte(strings.IndexByte(base, byte(v))))
 	}
-	hexSlice = append(hexSlice, 16)
+	nibbles[l-1] = 16
-
+	return nibbles
-	return hexSlice
 }
 
-func DecodeCompact(key []byte) string {
+func DecodeCompact(key []byte) []byte {
-	const base = "0123456789abcdef"
+	l := len(key) / 2
-	var str string
+	var res = make([]byte, l)
-
+	for i := 0; i < l; i++ {
-	for _, v := range key {
+		v1, v0 := key[2*i], key[2*i+1]
-		if v < 16 {
+		res[i] = v1*16 + v0
-			str += string(base[v])
 	}
-	}
+	return res
-
-	res, _ := hex.DecodeString(str)
-
-	return string(res)
 }

trie/encoding_test.go

@@ -17,9 +17,14 @@
 package trie
 
 import (
+	"encoding/hex"
+	"testing"
+
 	checker "gopkg.in/check.v1"
 )
 
+func Test(t *testing.T) { checker.TestingT(t) }
+
 type TrieEncodingSuite struct{}
 
 var _ = checker.Suite(&TrieEncodingSuite{})
@@ -28,48 +33,93 @@ func (s *TrieEncodingSuite) TestCompactEncode(c *checker.C) {
 	// even compact encode
 	test1 := []byte{1, 2, 3, 4, 5}
 	res1 := CompactEncode(test1)
-	c.Assert(res1, checker.Equals, "\x11\x23\x45")
+	c.Assert(res1, checker.DeepEquals, []byte("\x11\x23\x45"))
 
 	// odd compact encode
 	test2 := []byte{0, 1, 2, 3, 4, 5}
 	res2 := CompactEncode(test2)
-	c.Assert(res2, checker.Equals, "\x00\x01\x23\x45")
+	c.Assert(res2, checker.DeepEquals, []byte("\x00\x01\x23\x45"))
 
 	//odd terminated compact encode
 	test3 := []byte{0, 15, 1, 12, 11, 8 /*term*/, 16}
 	res3 := CompactEncode(test3)
-	c.Assert(res3, checker.Equals, "\x20\x0f\x1c\xb8")
+	c.Assert(res3, checker.DeepEquals, []byte("\x20\x0f\x1c\xb8"))
 
 	// even terminated compact encode
 	test4 := []byte{15, 1, 12, 11, 8 /*term*/, 16}
 	res4 := CompactEncode(test4)
-	c.Assert(res4, checker.Equals, "\x3f\x1c\xb8")
+	c.Assert(res4, checker.DeepEquals, []byte("\x3f\x1c\xb8"))
 }
 
 func (s *TrieEncodingSuite) TestCompactHexDecode(c *checker.C) {
 	exp := []byte{7, 6, 6, 5, 7, 2, 6, 2, 16}
-	res := CompactHexDecode("verb")
+	res := CompactHexDecode([]byte("verb"))
 	c.Assert(res, checker.DeepEquals, exp)
 }
 
 func (s *TrieEncodingSuite) TestCompactDecode(c *checker.C) {
 	// odd compact decode
 	exp := []byte{1, 2, 3, 4, 5}
-	res := CompactDecode("\x11\x23\x45")
+	res := CompactDecode([]byte("\x11\x23\x45"))
 	c.Assert(res, checker.DeepEquals, exp)
 
 	// even compact decode
 	exp = []byte{0, 1, 2, 3, 4, 5}
-	res = CompactDecode("\x00\x01\x23\x45")
+	res = CompactDecode([]byte("\x00\x01\x23\x45"))
 	c.Assert(res, checker.DeepEquals, exp)
 
 	// even terminated compact decode
 	exp = []byte{0, 15, 1, 12, 11, 8 /*term*/, 16}
-	res = CompactDecode("\x20\x0f\x1c\xb8")
+	res = CompactDecode([]byte("\x20\x0f\x1c\xb8"))
 	c.Assert(res, checker.DeepEquals, exp)
 
 	// even terminated compact decode
 	exp = []byte{15, 1, 12, 11, 8 /*term*/, 16}
-	res = CompactDecode("\x3f\x1c\xb8")
+	res = CompactDecode([]byte("\x3f\x1c\xb8"))
 	c.Assert(res, checker.DeepEquals, exp)
 }
+
+func (s *TrieEncodingSuite) TestDecodeCompact(c *checker.C) {
+	exp, _ := hex.DecodeString("012345")
+	res := DecodeCompact([]byte{0, 1, 2, 3, 4, 5})
+	c.Assert(res, checker.DeepEquals, exp)
+
+	exp, _ = hex.DecodeString("012345")
+	res = DecodeCompact([]byte{0, 1, 2, 3, 4, 5, 16})
+	c.Assert(res, checker.DeepEquals, exp)
+
+	exp, _ = hex.DecodeString("abcdef")
+	res = DecodeCompact([]byte{10, 11, 12, 13, 14, 15})
+	c.Assert(res, checker.DeepEquals, exp)
+}
+
+func BenchmarkCompactEncode(b *testing.B) {
+
+	testBytes := []byte{0, 15, 1, 12, 11, 8 /*term*/, 16}
+	for i := 0; i < b.N; i++ {
+		CompactEncode(testBytes)
+	}
+}
+
+func BenchmarkCompactDecode(b *testing.B) {
+	testBytes := []byte{0, 15, 1, 12, 11, 8 /*term*/, 16}
+	for i := 0; i < b.N; i++ {
+		CompactDecode(testBytes)
+	}
+}
+
+func BenchmarkCompactHexDecode(b *testing.B) {
+	testBytes := []byte{7, 6, 6, 5, 7, 2, 6, 2, 16}
+	for i := 0; i < b.N; i++ {
+		CompactHexDecode(testBytes)
+	}
+
+}
+
+func BenchmarkDecodeCompact(b *testing.B) {
+	testBytes := []byte{7, 6, 6, 5, 7, 2, 6, 2, 16}
+	for i := 0; i < b.N; i++ {
+		DecodeCompact(testBytes)
+	}
+
+}

trie/iterator.go

@@ -41,7 +41,7 @@ func (self *Iterator) Next() bool {
 		self.Key = make([]byte, 32)
 	}
 
-	key := RemTerm(CompactHexDecode(string(self.Key)))
+	key := RemTerm(CompactHexDecode(self.Key))
 	k := self.next(self.trie.root, key, isIterStart)
 
 	self.Key = []byte(DecodeCompact(k))

trie/shortnode.go

@@ -26,7 +26,7 @@ type ShortNode struct {
 }
 
 func NewShortNode(t *Trie, key []byte, value Node) *ShortNode {
-	return &ShortNode{t, []byte(CompactEncode(key)), value, false}
+	return &ShortNode{t, CompactEncode(key), value, false}
 }
 func (self *ShortNode) Value() Node {
 	self.value = self.trie.trans(self.value)
@@ -49,7 +49,7 @@ func (self *ShortNode) Hash() interface{} {
 }
 
 func (self *ShortNode) Key() []byte {
-	return CompactDecode(string(self.key))
+	return CompactDecode(self.key)
 }
 
 func (self *ShortNode) setDirty(dirty bool) {

trie/trie.go

@@ -27,6 +27,8 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 )
 
+var StatePre = []byte("state-")
+
 func ParanoiaCheck(t1 *Trie, backend Backend) (bool, *Trie) {
 	t2 := New(nil, backend)
 
@@ -69,7 +71,7 @@ func (self *Trie) Iterator() *Iterator {
 
 func (self *Trie) Copy() *Trie {
 	cpy := make([]byte, 32)
-	copy(cpy, self.roothash)
+	copy(cpy, self.roothash) // NOTE: cpy isn't being used anywhere?
 	trie := New(nil, nil)
 	trie.cache = self.cache.Copy()
 	if self.root != nil {
@@ -131,7 +133,7 @@ func (self *Trie) Update(key, value []byte) Node {
 	self.mu.Lock()
 	defer self.mu.Unlock()
 
-	k := CompactHexDecode(string(key))
+	k := CompactHexDecode(key)
 
 	if len(value) != 0 {
 		node := NewValueNode(self, value)
@@ -149,7 +151,7 @@ func (self *Trie) Get(key []byte) []byte {
 	self.mu.Lock()
 	defer self.mu.Unlock()
 
-	k := CompactHexDecode(string(key))
+	k := CompactHexDecode(key)
 
 	n := self.get(self.root, k)
 	if n != nil {
@@ -164,7 +166,7 @@ func (self *Trie) Delete(key []byte) Node {
 	self.mu.Lock()
 	defer self.mu.Unlock()
 
-	k := CompactHexDecode(string(key))
+	k := CompactHexDecode(key)
 	self.root = self.delete(self.root, k)
 
 	return self.root
@@ -336,7 +338,7 @@ func (self *Trie) mknode(value *common.Value) Node {
 	case 2:
 		// A value node may consists of 2 bytes.
 		if value.Get(0).Len() != 0 {
-			key := CompactDecode(string(value.Get(0).Bytes()))
+			key := CompactDecode(value.Get(0).Bytes())
 			if key[len(key)-1] == 16 {
 				return NewShortNode(self, key, NewValueNode(self, value.Get(1).Bytes()))
 			} else {

xeth/state.go

@@ -45,7 +45,7 @@ func (self *State) SafeGet(addr string) *Object {
 func (self *State) safeGet(addr string) *state.StateObject {
 	object := self.state.GetStateObject(common.HexToAddress(addr))
 	if object == nil {
-		object = state.NewStateObject(common.HexToAddress(addr), self.xeth.backend.StateDb())
+		object = state.NewStateObject(common.HexToAddress(addr), self.xeth.backend.ChainDb())
 	}
 
 	return object

xeth/xeth.go

@@ -20,8 +20,10 @@ package xeth
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"math/big"
+	"regexp"
 	"sync"
 	"time"
 
@@ -45,6 +47,7 @@ var (
 	defaultGasPrice  = big.NewInt(10000000000000) //150000000000
 	defaultGas       = big.NewInt(90000)          //500000
 	dappStorePre     = []byte("dapp-")
+	addrReg          = regexp.MustCompile(`^(0x)?[a-fA-F0-9]{40}$`)
 )
 
 // byte will be inferred
@@ -210,9 +213,9 @@ func (self *XEth) AtStateNum(num int64) *XEth {
 		st = self.backend.Miner().PendingState().Copy()
 	default:
 		if block := self.getBlockByHeight(num); block != nil {
-			st = state.New(block.Root(), self.backend.StateDb())
+			st = state.New(block.Root(), self.backend.ChainDb())
 		} else {
-			st = state.New(self.backend.ChainManager().GetBlockByNumber(0).Root(), self.backend.StateDb())
+			st = state.New(self.backend.ChainManager().GetBlockByNumber(0).Root(), self.backend.ChainDb())
 		}
 	}
 
@@ -256,7 +259,7 @@ func (self *XEth) UpdateState() (wait chan *big.Int) {
 						wait <- n
 						n = nil
 					}
-					statedb := state.New(ev.Block.Root(), self.backend.StateDb())
+					statedb := state.New(ev.Block.Root(), self.backend.ChainDb())
 					self.state = NewState(self, statedb)
 				}
 			case n, ok = <-wait:
@@ -308,7 +311,7 @@ func (self *XEth) EthBlockByHash(strHash string) *types.Block {
 func (self *XEth) EthTransactionByHash(hash string) (tx *types.Transaction, blhash common.Hash, blnum *big.Int, txi uint64) {
 	// Due to increasing return params and need to determine if this is from transaction pool or
 	// some chain, this probably needs to be refactored for more expressiveness
-	data, _ := self.backend.ExtraDb().Get(common.FromHex(hash))
+	data, _ := self.backend.ChainDb().Get(common.FromHex(hash))
 	if len(data) != 0 {
 		dtx := new(types.Transaction)
 		if err := rlp.DecodeBytes(data, dtx); err != nil {
@@ -327,7 +330,7 @@ func (self *XEth) EthTransactionByHash(hash string) (tx *types.Transaction, blha
 		Index      uint64
 	}
 
-	v, dberr := self.backend.ExtraDb().Get(append(common.FromHex(hash), 0x0001))
+	v, dberr := self.backend.ChainDb().Get(append(common.FromHex(hash), 0x0001))
 	// TODO check specifically for ErrNotFound
 	if dberr != nil {
 		return
@@ -362,7 +365,7 @@ func (self *XEth) GetBlockReceipts(bhash common.Hash) types.Receipts {
 }
 
 func (self *XEth) GetTxReceipt(txhash common.Hash) *types.Receipt {
-	return core.GetReceipt(self.backend.ExtraDb(), txhash)
+	return core.GetReceipt(self.backend.ChainDb(), txhash)
 }
 
 func (self *XEth) GasLimit() *big.Int {
@@ -405,13 +408,13 @@ func (self *XEth) SetSolc(solcPath string) (*compiler.Solidity, error) {
 
 // store DApp value in extra database
 func (self *XEth) DbPut(key, val []byte) bool {
-	self.backend.ExtraDb().Put(append(dappStorePre, key...), val)
+	self.backend.DappDb().Put(append(dappStorePre, key...), val)
 	return true
 }
 
 // retrieve DApp value from extra database
 func (self *XEth) DbGet(key []byte) ([]byte, error) {
-	val, err := self.backend.ExtraDb().Get(append(dappStorePre, key...))
+	val, err := self.backend.DappDb().Get(append(dappStorePre, key...))
 	return val, err
 }
 
@@ -878,6 +881,10 @@ func (self *XEth) Sign(fromStr, hashStr string, didUnlock bool) (string, error)
 	return common.ToHex(sig), nil
 }
 
+func isAddress(addr string) bool {
+	return addrReg.MatchString(addr)
+}
+
 func (self *XEth) Transact(fromStr, toStr, nonceStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) {
 
 	// this minimalistic recoding is enough (works for natspec.js)
@@ -887,6 +894,10 @@ func (self *XEth) Transact(fromStr, toStr, nonceStr, valueStr, gasStr, gasPriceS
 		return "", err
 	}
 
+	if len(toStr) > 0 && toStr != "0x" && !isAddress(toStr) {
+		return "", errors.New("Invalid address")
+	}
+
 	var (
 		from             = common.HexToAddress(fromStr)
 		to               = common.HexToAddress(toStr)

xeth/xeth_test.go

@@ -0,0 +1,26 @@
+package xeth
+
+import "testing"
+
+func TestIsAddress(t *testing.T) {
+	for _, invalid := range []string{
+		"0x00",
+		"0xNN",
+		"0x00000000000000000000000000000000000000NN",
+		"0xAAar000000000000000000000000000000000000",
+	} {
+		if isAddress(invalid) {
+			t.Error("Expected", invalid, "to be invalid")
+		}
+	}
+
+	for _, valid := range []string{
+		"0x0000000000000000000000000000000000000000",
+		"0xAABBbbCCccff9900000000000000000000000000",
+		"AABBbbCCccff9900000000000000000000000000",
+	} {
+		if !isAddress(valid) {
+			t.Error("Expected", valid, "to be valid")
+		}
+	}
+}