FreeBSD support

Former-commit-id: ff5dba816571945e8c0837f3ef52485da5fd7314 [formerly 2f23f618fd8f01331b593ab4e064138047fe7c77]
Former-commit-id: 1ec5e7440481e307be5e131ac0a416fd7d2fea9f

cmd/bootnode/main.go

@@ -0,0 +1,92 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+// bootnode runs a bootstrap node for the Ethereum Discovery Protocol.
+package main
+
+import (
+	"crypto/ecdsa"
+	"encoding/hex"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/p2p/discover"
+	"github.com/ethereum/go-ethereum/p2p/nat"
+)
+
+func main() {
+	var (
+		listenAddr  = flag.String("addr", ":30301", "listen address")
+		genKey      = flag.String("genkey", "", "generate a node key and quit")
+		nodeKeyFile = flag.String("nodekey", "", "private key filename")
+		nodeKeyHex  = flag.String("nodekeyhex", "", "private key as hex (for testing)")
+		natdesc     = flag.String("nat", "none", "port mapping mechanism (any|none|upnp|pmp|extip:<IP>)")
+
+		nodeKey *ecdsa.PrivateKey
+		err     error
+	)
+	flag.Parse()
+	logger.AddLogSystem(logger.NewStdLogSystem(os.Stdout, log.LstdFlags, logger.DebugLevel))
+
+	if *genKey != "" {
+		writeKey(*genKey)
+		os.Exit(0)
+	}
+
+	natm, err := nat.Parse(*natdesc)
+	if err != nil {
+		log.Fatalf("-nat: %v", err)
+	}
+	switch {
+	case *nodeKeyFile == "" && *nodeKeyHex == "":
+		log.Fatal("Use -nodekey or -nodekeyhex to specify a private key")
+	case *nodeKeyFile != "" && *nodeKeyHex != "":
+		log.Fatal("Options -nodekey and -nodekeyhex are mutually exclusive")
+	case *nodeKeyFile != "":
+		if nodeKey, err = crypto.LoadECDSA(*nodeKeyFile); err != nil {
+			log.Fatalf("-nodekey: %v", err)
+		}
+	case *nodeKeyHex != "":
+		if nodeKey, err = crypto.HexToECDSA(*nodeKeyHex); err != nil {
+			log.Fatalf("-nodekeyhex: %v", err)
+		}
+	}
+
+	if _, err := discover.ListenUDP(nodeKey, *listenAddr, natm, ""); err != nil {
+		log.Fatal(err)
+	}
+	select {}
+}
+
+func writeKey(target string) {
+	key, err := crypto.GenerateKey()
+	if err != nil {
+		log.Fatal("could not generate key: %v", err)
+	}
+	b := crypto.FromECDSA(key)
+	if target == "-" {
+		fmt.Println(hex.EncodeToString(b))
+	} else {
+		if err := ioutil.WriteFile(target, b, 0600); err != nil {
+			log.Fatal("write error: ", err)
+		}
+	}
+}

cmd/disasm/main.go

@@ -0,0 +1,51 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+// disasm is a pretty-printer for EVM bytecode.
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/vm"
+)
+
+func main() {
+	code, err := ioutil.ReadAll(os.Stdin)
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	code = common.Hex2Bytes(string(code[:len(code)-1]))
+	fmt.Printf("%x\n", code)
+
+	for pc := uint64(0); pc < uint64(len(code)); pc++ {
+		op := vm.OpCode(code[pc])
+		fmt.Printf("%-5d  %v", pc, op)
+
+		switch op {
+		case vm.PUSH1, vm.PUSH2, vm.PUSH3, vm.PUSH4, vm.PUSH5, vm.PUSH6, vm.PUSH7, vm.PUSH8, vm.PUSH9, vm.PUSH10, vm.PUSH11, vm.PUSH12, vm.PUSH13, vm.PUSH14, vm.PUSH15, vm.PUSH16, vm.PUSH17, vm.PUSH18, vm.PUSH19, vm.PUSH20, vm.PUSH21, vm.PUSH22, vm.PUSH23, vm.PUSH24, vm.PUSH25, vm.PUSH26, vm.PUSH27, vm.PUSH28, vm.PUSH29, vm.PUSH30, vm.PUSH31, vm.PUSH32:
+			a := uint64(op) - uint64(vm.PUSH1) + 1
+			fmt.Printf("  => %x", code[pc+1:pc+1+a])
+
+			pc += a
+		}
+		fmt.Println()
+	}
+}

cmd/ethtest/.bowerrc

@@ -0,0 +1,5 @@
+{
+  "directory": "example/js/",
+  "cwd": "./",
+  "analytics": false
+}

cmd/ethtest/.editorconfig

@@ -0,0 +1,12 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false

cmd/ethtest/.gitignore

@@ -0,0 +1,18 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile ~/.gitignore_global
+
+*.swp
+/tmp
+*/**/*un~
+*un~
+.DS_Store
+*/**/.DS_Store
+ethereum/ethereum
+ethereal/ethereal
+example/js
+node_modules
+bower_components
+npm-debug.log

cmd/ethtest/.jshintrc

@@ -0,0 +1,50 @@
+{
+    "predef": [
+        "console",
+        "require",
+        "equal",
+        "test",
+        "testBoth",
+        "testWithDefault",
+        "raises",
+        "deepEqual",
+        "start",
+        "stop",
+        "ok",
+        "strictEqual",
+        "module",
+        "expect",
+        "reject",
+        "impl"
+    ],
+
+    "esnext": true,
+    "proto": true,
+    "node" : true,
+    "browser" : true,
+    "browserify" : true,
+
+    "boss" : true,
+    "curly": false,
+    "debug": true,
+    "devel": true,
+    "eqeqeq": true,
+    "evil": true,
+    "forin": false,
+    "immed": false,
+    "laxbreak": false,
+    "newcap": true,
+    "noarg": true,
+    "noempty": false,
+    "nonew": false,
+    "nomen": false,
+    "onevar": false,
+    "plusplus": false,
+    "regexp": false,
+    "undef": true,
+    "sub": true,
+    "strict": false,
+    "white": false,
+    "shadow": true,
+    "eqnull": true
+}

cmd/ethtest/.npmignore

@@ -0,0 +1,9 @@
+example/js
+node_modules
+test
+.gitignore
+.editorconfig
+.travis.yml
+.npmignore
+component.json
+testling.html

cmd/ethtest/.travis.yml

@@ -0,0 +1,11 @@
+language: node_js
+node_js:
+  - "0.11"
+  - "0.10"
+before_script:
+  - npm install
+  - npm install jshint
+script:
+   - "jshint *.js lib"
+after_script:
+  - npm run-script gulp

cmd/ethtest/main.go

@@ -0,0 +1,214 @@
+// Copyright 2014 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+// ethtest executes Ethereum JSON tests.
+package main
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/codegangsta/cli"
+	"github.com/ethereum/go-ethereum/logger/glog"
+	"github.com/ethereum/go-ethereum/tests"
+)
+
+var (
+	continueOnError = false
+	testExtension   = ".json"
+	defaultTest     = "all"
+	defaultDir      = "."
+	allTests        = []string{"BlockTests", "StateTests", "TransactionTests", "VMTests", "RLPTests"}
+	skipTests       = []string{}
+
+	TestFlag = cli.StringFlag{
+		Name:  "test",
+		Usage: "Test type (string): VMTests, TransactionTests, StateTests, BlockTests",
+		Value: defaultTest,
+	}
+	FileFlag = cli.StringFlag{
+		Name:   "file",
+		Usage:  "Test file or directory. Directories are searched for .json files 1 level deep",
+		Value:  defaultDir,
+		EnvVar: "ETHEREUM_TEST_PATH",
+	}
+	ContinueOnErrorFlag = cli.BoolFlag{
+		Name:  "continue",
+		Usage: "Continue running tests on error (true) or [default] exit immediately (false)",
+	}
+	ReadStdInFlag = cli.BoolFlag{
+		Name:  "stdin",
+		Usage: "Accept input from stdin instead of reading from file",
+	}
+	SkipTestsFlag = cli.StringFlag{
+		Name:  "skip",
+		Usage: "Tests names to skip",
+	}
+)
+
+func runTestWithReader(test string, r io.Reader) error {
+	glog.Infoln("runTest", test)
+	var err error
+	switch strings.ToLower(test) {
+	case "bk", "block", "blocktest", "blockchaintest", "blocktests", "blockchaintests":
+		err = tests.RunBlockTestWithReader(r, skipTests)
+	case "st", "state", "statetest", "statetests":
+		err = tests.RunStateTestWithReader(r, skipTests)
+	case "tx", "transactiontest", "transactiontests":
+		err = tests.RunTransactionTestsWithReader(r, skipTests)
+	case "vm", "vmtest", "vmtests":
+		err = tests.RunVmTestWithReader(r, skipTests)
+	case "rlp", "rlptest", "rlptests":
+		err = tests.RunRLPTestWithReader(r, skipTests)
+	default:
+		err = fmt.Errorf("Invalid test type specified: %v", test)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func getFiles(path string) ([]string, error) {
+	glog.Infoln("getFiles", path)
+	var files []string
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	fi, err := f.Stat()
+	if err != nil {
+		return nil, err
+	}
+
+	switch mode := fi.Mode(); {
+	case mode.IsDir():
+		fi, _ := ioutil.ReadDir(path)
+		files = make([]string, len(fi))
+		for i, v := range fi {
+			// only go 1 depth and leave directory entires blank
+			if !v.IsDir() && v.Name()[len(v.Name())-len(testExtension):len(v.Name())] == testExtension {
+				files[i] = filepath.Join(path, v.Name())
+				glog.Infoln("Found file", files[i])
+			}
+		}
+	case mode.IsRegular():
+		files = make([]string, 1)
+		files[0] = path
+	}
+
+	return files, nil
+}
+
+func runSuite(test, file string) {
+	var tests []string
+
+	if test == defaultTest {
+		tests = allTests
+	} else {
+		tests = []string{test}
+	}
+
+	for _, curTest := range tests {
+		glog.Infoln("runSuite", curTest, file)
+		var err error
+		var files []string
+		if test == defaultTest {
+			files, err = getFiles(filepath.Join(file, curTest))
+
+		} else {
+			files, err = getFiles(file)
+		}
+		if err != nil {
+			glog.Fatalln(err)
+		}
+
+		if len(files) == 0 {
+			glog.Warningln("No files matched path")
+		}
+		for _, curFile := range files {
+			// Skip blank entries
+			if len(curFile) == 0 {
+				continue
+			}
+
+			r, err := os.Open(curFile)
+			if err != nil {
+				glog.Fatalln(err)
+			}
+			defer r.Close()
+
+			err = runTestWithReader(curTest, r)
+			if err != nil {
+				if continueOnError {
+					glog.Errorln(err)
+				} else {
+					glog.Fatalln(err)
+				}
+			}
+
+		}
+	}
+}
+
+func setupApp(c *cli.Context) {
+	flagTest := c.GlobalString(TestFlag.Name)
+	flagFile := c.GlobalString(FileFlag.Name)
+	continueOnError = c.GlobalBool(ContinueOnErrorFlag.Name)
+	useStdIn := c.GlobalBool(ReadStdInFlag.Name)
+	skipTests = strings.Split(c.GlobalString(SkipTestsFlag.Name), " ")
+
+	if !useStdIn {
+		runSuite(flagTest, flagFile)
+	} else {
+		if err := runTestWithReader(flagTest, os.Stdin); err != nil {
+			glog.Fatalln(err)
+		}
+
+	}
+}
+
+func main() {
+	glog.SetToStderr(true)
+
+	app := cli.NewApp()
+	app.Name = "ethtest"
+	app.Usage = "go-ethereum test interface"
+	app.Action = setupApp
+	app.Version = "0.2.0"
+	app.Author = "go-ethereum team"
+
+	app.Flags = []cli.Flag{
+		TestFlag,
+		FileFlag,
+		ContinueOnErrorFlag,
+		ReadStdInFlag,
+		SkipTestsFlag,
+	}
+
+	if err := app.Run(os.Args); err != nil {
+		glog.Fatalln(err)
+	}
+
+}

cmd/evm/code.txt

@@ -0,0 +1 @@
+60006102ff5360003560001a60008114156103395760013560405260216040516020025990590160009052606052604051602002816060513760405160200281019050506002604051121561005957604051602002606051f35b604051602002599059016000905260a052600060c052604051602002599059016000905260e0526000610100526001610120525b604051610120511215610109576060515161012051602002606051015112156100d8576101205160200260605101516101005160200260e051015260016101005101610100526100f9565b61012051602002606051015160c05160200260a0510152600160c0510160c0525b600161012051016101205261008d565b60216020599059016000905260c051808252806020028301925050602082015990590160009052600081538151600182015260218101825160200260a0518260005b8381101561016657808301518186015260208101905061014b565b50505050825160200281019050604059905901600090526102405281610240515283602061024051015261024051905090509050905060c05160200280599059016000905281816020850151855160003060195a03f1508090509050905060a05260216020599059016000905261010051808252806020028301925050602082015990590160009052600081538151600182015260218101825160200260e0518260005b8381101561022557808301518186015260208101905061020a565b50505050825160200281019050604059905901600090526102c052816102c051528360206102c05101526102c05190509050905090506101005160200280599059016000905281816020850151855160003060195a03f1508090509050905060e05260405160200259905901600090526102e0526000610120525b610100516101205112156102d7576101205160200260e0510151610120516020026102e051015260016101205101610120526102a0565b60605151610100516020026102e05101526000610120525b60c05161012051121561032d576101205160200260a05101516101205160016101005101016020026102e051015260016101205101610120526102ef565b6040516020026102e051f35b50

cmd/evm/main.go

@@ -0,0 +1,219 @@
+// Copyright 2014 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+// evm executes EVM code snippets.
+package main
+
+import (
+	"fmt"
+	"math/big"
+	"os"
+	"runtime"
+	"time"
+
+	"github.com/codegangsta/cli"
+	"github.com/ethereum/go-ethereum/cmd/utils"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/ethdb"
+)
+
+var (
+	app       *cli.App
+	DebugFlag = cli.BoolFlag{
+		Name:  "debug",
+		Usage: "output full trace logs",
+	}
+	CodeFlag = cli.StringFlag{
+		Name:  "code",
+		Usage: "EVM code",
+	}
+	GasFlag = cli.StringFlag{
+		Name:  "gas",
+		Usage: "gas limit for the evm",
+		Value: "10000000000",
+	}
+	PriceFlag = cli.StringFlag{
+		Name:  "price",
+		Usage: "price set for the evm",
+		Value: "0",
+	}
+	ValueFlag = cli.StringFlag{
+		Name:  "value",
+		Usage: "value set for the evm",
+		Value: "0",
+	}
+	DumpFlag = cli.BoolFlag{
+		Name:  "dump",
+		Usage: "dumps the state after the run",
+	}
+	InputFlag = cli.StringFlag{
+		Name:  "input",
+		Usage: "input for the EVM",
+	}
+	SysStatFlag = cli.BoolFlag{
+		Name:  "sysstat",
+		Usage: "display system stats",
+	}
+)
+
+func init() {
+	app = utils.NewApp("0.2", "the evm command line interface")
+	app.Flags = []cli.Flag{
+		DebugFlag,
+		SysStatFlag,
+		CodeFlag,
+		GasFlag,
+		PriceFlag,
+		ValueFlag,
+		DumpFlag,
+		InputFlag,
+	}
+	app.Action = run
+}
+
+func run(ctx *cli.Context) {
+	vm.Debug = ctx.GlobalBool(DebugFlag.Name)
+
+	db, _ := ethdb.NewMemDatabase()
+	statedb := state.New(common.Hash{}, db)
+	sender := statedb.CreateAccount(common.StringToAddress("sender"))
+	receiver := statedb.CreateAccount(common.StringToAddress("receiver"))
+	receiver.SetCode(common.Hex2Bytes(ctx.GlobalString(CodeFlag.Name)))
+
+	vmenv := NewEnv(statedb, common.StringToAddress("evmuser"), common.Big(ctx.GlobalString(ValueFlag.Name)))
+
+	tstart := time.Now()
+	ret, e := vmenv.Call(
+		sender,
+		receiver.Address(),
+		common.Hex2Bytes(ctx.GlobalString(InputFlag.Name)),
+		common.Big(ctx.GlobalString(GasFlag.Name)),
+		common.Big(ctx.GlobalString(PriceFlag.Name)),
+		common.Big(ctx.GlobalString(ValueFlag.Name)),
+	)
+	vmdone := time.Since(tstart)
+
+	if e != nil {
+		fmt.Println(e)
+		os.Exit(1)
+	}
+
+	if ctx.GlobalBool(DumpFlag.Name) {
+		fmt.Println(string(statedb.Dump()))
+	}
+	vm.StdErrFormat(vmenv.StructLogs())
+
+	if ctx.GlobalBool(SysStatFlag.Name) {
+		var mem runtime.MemStats
+		runtime.ReadMemStats(&mem)
+		fmt.Printf("vm took %v\n", vmdone)
+		fmt.Printf(`alloc:      %d
+tot alloc:  %d
+no. malloc: %d
+heap alloc: %d
+heap objs:  %d
+num gc:     %d
+`, mem.Alloc, mem.TotalAlloc, mem.Mallocs, mem.HeapAlloc, mem.HeapObjects, mem.NumGC)
+	}
+
+	fmt.Printf("OUT: 0x%x\n", ret)
+}
+
+func main() {
+	if err := app.Run(os.Args); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+type VMEnv struct {
+	state *state.StateDB
+	block *types.Block
+
+	transactor *common.Address
+	value      *big.Int
+
+	depth int
+	Gas   *big.Int
+	time  uint64
+	logs  []vm.StructLog
+}
+
+func NewEnv(state *state.StateDB, transactor common.Address, value *big.Int) *VMEnv {
+	return &VMEnv{
+		state:      state,
+		transactor: &transactor,
+		value:      value,
+		time:       uint64(time.Now().Unix()),
+	}
+}
+
+func (self *VMEnv) State() *state.StateDB    { return self.state }
+func (self *VMEnv) Origin() common.Address   { return *self.transactor }
+func (self *VMEnv) BlockNumber() *big.Int    { return common.Big0 }
+func (self *VMEnv) Coinbase() common.Address { return *self.transactor }
+func (self *VMEnv) Time() uint64             { return self.time }
+func (self *VMEnv) Difficulty() *big.Int     { return common.Big1 }
+func (self *VMEnv) BlockHash() []byte        { return make([]byte, 32) }
+func (self *VMEnv) Value() *big.Int          { return self.value }
+func (self *VMEnv) GasLimit() *big.Int       { return big.NewInt(1000000000) }
+func (self *VMEnv) VmType() vm.Type          { return vm.StdVmTy }
+func (self *VMEnv) Depth() int               { return 0 }
+func (self *VMEnv) SetDepth(i int)           { self.depth = i }
+func (self *VMEnv) GetHash(n uint64) common.Hash {
+	if self.block.Number().Cmp(big.NewInt(int64(n))) == 0 {
+		return self.block.Hash()
+	}
+	return common.Hash{}
+}
+func (self *VMEnv) AddStructLog(log vm.StructLog) {
+	self.logs = append(self.logs, log)
+}
+func (self *VMEnv) StructLogs() []vm.StructLog {
+	return self.logs
+}
+func (self *VMEnv) AddLog(log *state.Log) {
+	self.state.AddLog(log)
+}
+func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error {
+	return vm.Transfer(from, to, amount)
+}
+
+func (self *VMEnv) vm(addr *common.Address, data []byte, gas, price, value *big.Int) *core.Execution {
+	return core.NewExecution(self, addr, data, gas, price, value)
+}
+
+func (self *VMEnv) Call(caller vm.ContextRef, addr common.Address, data []byte, gas, price, value *big.Int) ([]byte, error) {
+	exe := self.vm(&addr, data, gas, price, value)
+	ret, err := exe.Call(addr, caller)
+	self.Gas = exe.Gas
+
+	return ret, err
+}
+func (self *VMEnv) CallCode(caller vm.ContextRef, addr common.Address, data []byte, gas, price, value *big.Int) ([]byte, error) {
+	a := caller.Address()
+	exe := self.vm(&a, data, gas, price, value)
+	return exe.Call(addr, caller)
+}
+
+func (self *VMEnv) Create(caller vm.ContextRef, data []byte, gas, price, value *big.Int) ([]byte, error, vm.ContextRef) {
+	exe := self.vm(nil, data, gas, price, value)
+	return exe.Create(caller)
+}

cmd/geth/blocktestcmd.go

@@ -0,0 +1,136 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/codegangsta/cli"
+	"github.com/ethereum/go-ethereum/cmd/utils"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/eth"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/tests"
+)
+
+var blocktestCommand = cli.Command{
+	Action: runBlockTest,
+	Name:   "blocktest",
+	Usage:  `loads a block test file`,
+	Description: `
+The first argument should be a block test file.
+The second argument is the name of a block test from the file.
+
+The block test will be loaded into an in-memory database.
+If loading succeeds, the RPC server is started. Clients will
+be able to interact with the chain defined by the test.
+`,
+}
+
+func runBlockTest(ctx *cli.Context) {
+	var (
+		file, testname string
+		rpc            bool
+	)
+	args := ctx.Args()
+	switch {
+	case len(args) == 1:
+		file = args[0]
+	case len(args) == 2:
+		file, testname = args[0], args[1]
+	case len(args) == 3:
+		file, testname = args[0], args[1]
+		rpc = true
+	default:
+		utils.Fatalf(`Usage: ethereum blocktest <path-to-test-file> [ <test-name> [ "rpc" ] ]`)
+	}
+	bt, err := tests.LoadBlockTests(file)
+	if err != nil {
+		utils.Fatalf("%v", err)
+	}
+
+	// run all tests if no test name is specified
+	if testname == "" {
+		ecode := 0
+		for name, test := range bt {
+			fmt.Printf("----------------- Running Block Test %q\n", name)
+			ethereum, err := runOneBlockTest(ctx, test)
+			if err != nil {
+				fmt.Println(err)
+				fmt.Println("FAIL")
+				ecode = 1
+			}
+			if ethereum != nil {
+				ethereum.Stop()
+				ethereum.WaitForShutdown()
+			}
+		}
+		os.Exit(ecode)
+		return
+	}
+	// otherwise, run the given test
+	test, ok := bt[testname]
+	if !ok {
+		utils.Fatalf("Test file does not contain test named %q", testname)
+	}
+	ethereum, err := runOneBlockTest(ctx, test)
+	if err != nil {
+		utils.Fatalf("%v", err)
+	}
+	defer ethereum.Stop()
+	if rpc {
+		fmt.Println("Block Test post state validated, starting RPC interface.")
+		startEth(ctx, ethereum)
+		utils.StartRPC(ethereum, ctx)
+		ethereum.WaitForShutdown()
+	}
+}
+
+func runOneBlockTest(ctx *cli.Context, test *tests.BlockTest) (*eth.Ethereum, error) {
+	cfg := utils.MakeEthConfig(ClientIdentifier, Version, ctx)
+	cfg.NewDB = func(path string) (common.Database, error) { return ethdb.NewMemDatabase() }
+	cfg.MaxPeers = 0 // disable network
+	cfg.Shh = false  // disable whisper
+	cfg.NAT = nil    // disable port mapping
+
+	ethereum, err := eth.New(cfg)
+	if err != nil {
+		return nil, err
+	}
+	// if err := ethereum.Start(); err != nil {
+	// 	return nil, err
+	// }
+
+	// import the genesis block
+	ethereum.ResetWithGenesisBlock(test.Genesis)
+
+	// import pre accounts
+	statedb, err := test.InsertPreState(ethereum)
+	if err != nil {
+		return ethereum, fmt.Errorf("InsertPreState: %v", err)
+	}
+
+	if err := test.TryBlocksInsert(ethereum.ChainManager()); err != nil {
+		return ethereum, fmt.Errorf("Block Test load error: %v", err)
+	}
+
+	if err := test.ValidatePostState(statedb); err != nil {
+		return ethereum, fmt.Errorf("post state validation failed: %v", err)
+	}
+	return ethereum, nil
+}

cmd/geth/chaincmd.go

@@ -0,0 +1,199 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"time"
+
+	"github.com/codegangsta/cli"
+	"github.com/ethereum/go-ethereum/cmd/utils"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/logger/glog"
+)
+
+var (
+	importCommand = cli.Command{
+		Action: importChain,
+		Name:   "import",
+		Usage:  `import a blockchain file`,
+	}
+	exportCommand = cli.Command{
+		Action: exportChain,
+		Name:   "export",
+		Usage:  `export blockchain into file`,
+		Description: `
+Requires a first argument of the file to write to.
+Optional second and third arguments control the first and
+last block to write. In this mode, the file will be appended
+if already existing.
+		`,
+	}
+	upgradedbCommand = cli.Command{
+		Action: upgradeDB,
+		Name:   "upgradedb",
+		Usage:  "upgrade chainblock database",
+	}
+	removedbCommand = cli.Command{
+		Action: removeDB,
+		Name:   "removedb",
+		Usage:  "Remove blockchain and state databases",
+	}
+	dumpCommand = cli.Command{
+		Action: dump,
+		Name:   "dump",
+		Usage:  `dump a specific block from storage`,
+		Description: `
+The arguments are interpreted as block numbers or hashes.
+Use "ethereum dump 0" to dump the genesis block.
+`,
+	}
+)
+
+func importChain(ctx *cli.Context) {
+	if len(ctx.Args()) != 1 {
+		utils.Fatalf("This command requires an argument.")
+	}
+	chain, blockDB, stateDB, extraDB := utils.MakeChain(ctx)
+	start := time.Now()
+	err := utils.ImportChain(chain, ctx.Args().First())
+	closeAll(blockDB, stateDB, extraDB)
+	if err != nil {
+		utils.Fatalf("Import error: %v", err)
+	}
+	fmt.Printf("Import done in %v", time.Since(start))
+}
+
+func exportChain(ctx *cli.Context) {
+	if len(ctx.Args()) < 1 {
+		utils.Fatalf("This command requires an argument.")
+	}
+	chain, _, _, _ := utils.MakeChain(ctx)
+	start := time.Now()
+
+	var err error
+	fp := ctx.Args().First()
+	if len(ctx.Args()) < 3 {
+		err = utils.ExportChain(chain, fp)
+	} else {
+		// This can be improved to allow for numbers larger than 9223372036854775807
+		first, ferr := strconv.ParseInt(ctx.Args().Get(1), 10, 64)
+		last, lerr := strconv.ParseInt(ctx.Args().Get(2), 10, 64)
+		if ferr != nil || lerr != nil {
+			utils.Fatalf("Export error in parsing parameters: block number not an integer\n")
+		}
+		if first < 0 || last < 0 {
+			utils.Fatalf("Export error: block number must be greater than 0\n")
+		}
+		err = utils.ExportAppendChain(chain, fp, uint64(first), uint64(last))
+	}
+
+	if err != nil {
+		utils.Fatalf("Export error: %v\n", err)
+	}
+	fmt.Printf("Export done in %v", time.Since(start))
+}
+
+func removeDB(ctx *cli.Context) {
+	confirm, err := utils.PromptConfirm("Remove local databases?")
+	if err != nil {
+		utils.Fatalf("%v", err)
+	}
+
+	if confirm {
+		fmt.Println("Removing chain and state databases...")
+		start := time.Now()
+
+		os.RemoveAll(filepath.Join(ctx.GlobalString(utils.DataDirFlag.Name), "blockchain"))
+		os.RemoveAll(filepath.Join(ctx.GlobalString(utils.DataDirFlag.Name), "state"))
+
+		fmt.Printf("Removed in %v\n", time.Since(start))
+	} else {
+		fmt.Println("Operation aborted")
+	}
+}
+
+func upgradeDB(ctx *cli.Context) {
+	glog.Infoln("Upgrading blockchain database")
+
+	chain, blockDB, stateDB, extraDB := utils.MakeChain(ctx)
+	v, _ := blockDB.Get([]byte("BlockchainVersion"))
+	bcVersion := int(common.NewValue(v).Uint())
+	if bcVersion == 0 {
+		bcVersion = core.BlockChainVersion
+	}
+
+	// Export the current chain.
+	filename := fmt.Sprintf("blockchain_%d_%s.chain", bcVersion, time.Now().Format("20060102_150405"))
+	exportFile := filepath.Join(ctx.GlobalString(utils.DataDirFlag.Name), filename)
+	if err := utils.ExportChain(chain, exportFile); err != nil {
+		utils.Fatalf("Unable to export chain for reimport %s", err)
+	}
+	closeAll(blockDB, stateDB, extraDB)
+	os.RemoveAll(filepath.Join(ctx.GlobalString(utils.DataDirFlag.Name), "blockchain"))
+	os.RemoveAll(filepath.Join(ctx.GlobalString(utils.DataDirFlag.Name), "state"))
+
+	// Import the chain file.
+	chain, blockDB, stateDB, extraDB = utils.MakeChain(ctx)
+	blockDB.Put([]byte("BlockchainVersion"), common.NewValue(core.BlockChainVersion).Bytes())
+	err := utils.ImportChain(chain, exportFile)
+	closeAll(blockDB, stateDB, extraDB)
+	if err != nil {
+		utils.Fatalf("Import error %v (a backup is made in %s, use the import command to import it)", err, exportFile)
+	} else {
+		os.Remove(exportFile)
+		glog.Infoln("Import finished")
+	}
+}
+
+func dump(ctx *cli.Context) {
+	chain, _, stateDB, _ := utils.MakeChain(ctx)
+	for _, arg := range ctx.Args() {
+		var block *types.Block
+		if hashish(arg) {
+			block = chain.GetBlock(common.HexToHash(arg))
+		} else {
+			num, _ := strconv.Atoi(arg)
+			block = chain.GetBlockByNumber(uint64(num))
+		}
+		if block == nil {
+			fmt.Println("{}")
+			utils.Fatalf("block not found")
+		} else {
+			state := state.New(block.Root(), stateDB)
+			fmt.Printf("%s\n", state.Dump())
+		}
+	}
+}
+
+// hashish returns true for strings that look like hashes.
+func hashish(x string) bool {
+	_, err := strconv.Atoi(x)
+	return err != nil
+}
+
+func closeAll(dbs ...common.Database) {
+	for _, db := range dbs {
+		db.Close()
+	}
+}

cmd/geth/info_test.json

@@ -0,0 +1 @@
+{"code":"0x605880600c6000396000f3006000357c010000000000000000000000000000000000000000000000000000000090048063c6888fa114602e57005b603d6004803590602001506047565b8060005260206000f35b60006007820290506053565b91905056","info":{"abiDefinition":[{"constant":false,"inputs":[{"name":"a","type":"uint256"}],"name":"multiply","outputs":[{"name":"d","type":"uint256"}],"type":"function"}],"compilerVersion":"0.9.23","developerDoc":{"methods":{}},"language":"Solidity","languageVersion":"0","source":"contract test {\n   /// @notice Will multiply `a` by 7.\n   function multiply(uint a) returns(uint d) {\n       return a * 7;\n   }\n}\n","userDoc":{"methods":{"multiply(uint256)":{"notice":"Will multiply `a` by 7."}}}}}

cmd/geth/js.go

@@ -0,0 +1,480 @@
+// Copyright 2014 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"math/big"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"strings"
+
+	"sort"
+
+	"github.com/ethereum/go-ethereum/cmd/utils"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/docserver"
+	"github.com/ethereum/go-ethereum/common/natspec"
+	"github.com/ethereum/go-ethereum/common/registrar"
+	"github.com/ethereum/go-ethereum/eth"
+	re "github.com/ethereum/go-ethereum/jsre"
+	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/ethereum/go-ethereum/rpc/api"
+	"github.com/ethereum/go-ethereum/rpc/codec"
+	"github.com/ethereum/go-ethereum/rpc/comms"
+	"github.com/ethereum/go-ethereum/rpc/shared"
+	"github.com/ethereum/go-ethereum/xeth"
+	"github.com/peterh/liner"
+	"github.com/robertkrimen/otto"
+)
+
+type prompter interface {
+	AppendHistory(string)
+	Prompt(p string) (string, error)
+	PasswordPrompt(p string) (string, error)
+}
+
+type dumbterm struct{ r *bufio.Reader }
+
+func (r dumbterm) Prompt(p string) (string, error) {
+	fmt.Print(p)
+	line, err := r.r.ReadString('\n')
+	return strings.TrimSuffix(line, "\n"), err
+}
+
+func (r dumbterm) PasswordPrompt(p string) (string, error) {
+	fmt.Println("!! Unsupported terminal, password will echo.")
+	fmt.Print(p)
+	input, err := bufio.NewReader(os.Stdin).ReadString('\n')
+	fmt.Println()
+	return input, err
+}
+
+func (r dumbterm) AppendHistory(string) {}
+
+type jsre struct {
+	ds         *docserver.DocServer
+	re         *re.JSRE
+	ethereum   *eth.Ethereum
+	xeth       *xeth.XEth
+	wait       chan *big.Int
+	ps1        string
+	atexit     func()
+	corsDomain string
+	client     comms.EthereumClient
+	prompter
+}
+
+var (
+	loadedModulesMethods map[string][]string
+)
+
+func keywordCompleter(line string) []string {
+	results := make([]string, 0)
+
+	if strings.Contains(line, ".") {
+		elements := strings.Split(line, ".")
+		if len(elements) == 2 {
+			module := elements[0]
+			partialMethod := elements[1]
+			if methods, found := loadedModulesMethods[module]; found {
+				for _, method := range methods {
+					if strings.HasPrefix(method, partialMethod) { // e.g. debug.se
+						results = append(results, module+"."+method)
+					}
+				}
+			}
+		}
+	} else {
+		for module, methods := range loadedModulesMethods {
+			if line == module { // user typed in full module name, show all methods
+				for _, method := range methods {
+					results = append(results, module+"."+method)
+				}
+			} else if strings.HasPrefix(module, line) { // partial method name, e.g. admi
+				results = append(results, module)
+			}
+		}
+	}
+	return results
+}
+
+func apiWordCompleter(line string, pos int) (head string, completions []string, tail string) {
+	if len(line) == 0 {
+		return "", nil, ""
+	}
+
+	i := 0
+	for i = pos - 1; i > 0; i-- {
+		if line[i] == '.' || (line[i] >= 'a' && line[i] <= 'z') || (line[i] >= 'A' && line[i] <= 'Z') {
+			continue
+		}
+		if i >= 3 && line[i] == '3' && line[i-3] == 'w' && line[i-2] == 'e' && line[i-1] == 'b' {
+			continue
+		}
+		i += 1
+		break
+	}
+
+	begin := line[:i]
+	keyword := line[i:pos]
+	end := line[pos:]
+
+	completionWords := keywordCompleter(keyword)
+	return begin, completionWords, end
+}
+
+func newLightweightJSRE(libPath string, client comms.EthereumClient, interactive bool, f xeth.Frontend) *jsre {
+	js := &jsre{ps1: "> "}
+	js.wait = make(chan *big.Int)
+	js.client = client
+	js.ds = docserver.New("/")
+
+	if f == nil {
+		f = js
+	}
+
+	// update state in separare forever blocks
+	js.re = re.New(libPath)
+	if err := js.apiBindings(f); err != nil {
+		utils.Fatalf("Unable to initialize console - %v", err)
+	}
+
+	if !liner.TerminalSupported() || !interactive {
+		js.prompter = dumbterm{bufio.NewReader(os.Stdin)}
+	} else {
+		lr := liner.NewLiner()
+		js.withHistory(func(hist *os.File) { lr.ReadHistory(hist) })
+		lr.SetCtrlCAborts(true)
+		js.loadAutoCompletion()
+		lr.SetWordCompleter(apiWordCompleter)
+		lr.SetTabCompletionStyle(liner.TabPrints)
+		js.prompter = lr
+		js.atexit = func() {
+			js.withHistory(func(hist *os.File) { hist.Truncate(0); lr.WriteHistory(hist) })
+			lr.Close()
+			close(js.wait)
+		}
+	}
+	return js
+}
+
+func newJSRE(ethereum *eth.Ethereum, libPath, corsDomain string, client comms.EthereumClient, interactive bool, f xeth.Frontend) *jsre {
+	js := &jsre{ethereum: ethereum, ps1: "> "}
+	// set default cors domain used by startRpc from CLI flag
+	js.corsDomain = corsDomain
+	if f == nil {
+		f = js
+	}
+	js.ds = docserver.New("/")
+	js.xeth = xeth.New(ethereum, f)
+	js.wait = js.xeth.UpdateState()
+	js.client = client
+	if clt, ok := js.client.(*comms.InProcClient); ok {
+		if offeredApis, err := api.ParseApiString(shared.AllApis, codec.JSON, js.xeth, ethereum); err == nil {
+			clt.Initialize(api.Merge(offeredApis...))
+		}
+	}
+
+	// update state in separare forever blocks
+	js.re = re.New(libPath)
+	if err := js.apiBindings(f); err != nil {
+		utils.Fatalf("Unable to connect - %v", err)
+	}
+
+	if !liner.TerminalSupported() || !interactive {
+		js.prompter = dumbterm{bufio.NewReader(os.Stdin)}
+	} else {
+		lr := liner.NewLiner()
+		js.withHistory(func(hist *os.File) { lr.ReadHistory(hist) })
+		lr.SetCtrlCAborts(true)
+		js.loadAutoCompletion()
+		lr.SetWordCompleter(apiWordCompleter)
+		lr.SetTabCompletionStyle(liner.TabPrints)
+		js.prompter = lr
+		js.atexit = func() {
+			js.withHistory(func(hist *os.File) { hist.Truncate(0); lr.WriteHistory(hist) })
+			lr.Close()
+			close(js.wait)
+		}
+	}
+	return js
+}
+
+func (self *jsre) loadAutoCompletion() {
+	if modules, err := self.supportedApis(); err == nil {
+		loadedModulesMethods = make(map[string][]string)
+		for module, _ := range modules {
+			loadedModulesMethods[module] = api.AutoCompletion[module]
+		}
+	}
+}
+
+func (self *jsre) batch(statement string) {
+	val, err := self.re.Run(statement)
+
+	if err != nil {
+		fmt.Printf("error: %v", err)
+	} else if val.IsDefined() && val.IsObject() {
+		obj, _ := self.re.Get("ret_result")
+		fmt.Printf("%v", obj)
+	} else if val.IsDefined() {
+		fmt.Printf("%v", val)
+	}
+
+	if self.atexit != nil {
+		self.atexit()
+	}
+
+	self.re.Stop(false)
+}
+
+// show summary of current geth instance
+func (self *jsre) welcome() {
+	self.re.Eval(`console.log('instance: ' + web3.version.client);`)
+	self.re.Eval(`console.log(' datadir: ' + admin.datadir);`)
+	self.re.Eval(`console.log("coinbase: " + eth.coinbase);`)
+	self.re.Eval(`var lastBlockTimestamp = 1000 * eth.getBlock(eth.blockNumber).timestamp`)
+	self.re.Eval(`console.log("at block: " + eth.blockNumber + " (" + new Date(lastBlockTimestamp).toLocaleDateString()
+		+ " " + new Date(lastBlockTimestamp).toLocaleTimeString() + ")");`)
+
+	if modules, err := self.supportedApis(); err == nil {
+		loadedModules := make([]string, 0)
+		for api, version := range modules {
+			loadedModules = append(loadedModules, fmt.Sprintf("%s:%s", api, version))
+		}
+		sort.Strings(loadedModules)
+
+		self.re.Eval(fmt.Sprintf("var modules = '%s';", strings.Join(loadedModules, " ")))
+		self.re.Eval(`console.log(" modules: " + modules);`)
+	}
+}
+
+func (self *jsre) supportedApis() (map[string]string, error) {
+	return self.client.SupportedModules()
+}
+
+func (js *jsre) apiBindings(f xeth.Frontend) error {
+	apis, err := js.supportedApis()
+	if err != nil {
+		return err
+	}
+
+	apiNames := make([]string, 0, len(apis))
+	for a, _ := range apis {
+		apiNames = append(apiNames, a)
+	}
+
+	apiImpl, err := api.ParseApiString(strings.Join(apiNames, ","), codec.JSON, js.xeth, js.ethereum)
+	if err != nil {
+		utils.Fatalf("Unable to determine supported api's: %v", err)
+	}
+
+	jeth := rpc.NewJeth(api.Merge(apiImpl...), js.re, js.client)
+	js.re.Set("jeth", struct{}{})
+	t, _ := js.re.Get("jeth")
+	jethObj := t.Object()
+
+	jethObj.Set("send", jeth.Send)
+	jethObj.Set("sendAsync", jeth.Send)
+
+	err = js.re.Compile("bignumber.js", re.BigNumber_JS)
+	if err != nil {
+		utils.Fatalf("Error loading bignumber.js: %v", err)
+	}
+
+	err = js.re.Compile("ethereum.js", re.Web3_JS)
+	if err != nil {
+		utils.Fatalf("Error loading web3.js: %v", err)
+	}
+
+	_, err = js.re.Eval("var web3 = require('web3');")
+	if err != nil {
+		utils.Fatalf("Error requiring web3: %v", err)
+	}
+
+	_, err = js.re.Eval("web3.setProvider(jeth)")
+	if err != nil {
+		utils.Fatalf("Error setting web3 provider: %v", err)
+	}
+
+	// load only supported API's in javascript runtime
+	shortcuts := "var eth = web3.eth; "
+	for _, apiName := range apiNames {
+		if apiName == shared.Web3ApiName {
+			continue // manually mapped
+		}
+
+		if err = js.re.Compile(fmt.Sprintf("%s.js", apiName), api.Javascript(apiName)); err == nil {
+			shortcuts += fmt.Sprintf("var %s = web3.%s; ", apiName, apiName)
+		} else {
+			utils.Fatalf("Error loading %s.js: %v", apiName, err)
+		}
+	}
+
+	_, err = js.re.Eval(shortcuts)
+
+	if err != nil {
+		utils.Fatalf("Error setting namespaces: %v", err)
+	}
+
+	js.re.Eval(`var GlobalRegistrar = eth.contract(` + registrar.GlobalRegistrarAbi + `);	 registrar = GlobalRegistrar.at("` + registrar.GlobalRegistrarAddr + `");`)
+	return nil
+}
+
+func (self *jsre) ConfirmTransaction(tx string) bool {
+	if self.ethereum.NatSpec {
+		notice := natspec.GetNotice(self.xeth, tx, self.ds)
+		fmt.Println(notice)
+		answer, _ := self.Prompt("Confirm Transaction [y/n]")
+		return strings.HasPrefix(strings.Trim(answer, " "), "y")
+	} else {
+		return true
+	}
+}
+
+func (self *jsre) UnlockAccount(addr []byte) bool {
+	fmt.Printf("Please unlock account %x.\n", addr)
+	pass, err := self.PasswordPrompt("Passphrase: ")
+	if err != nil {
+		return false
+	}
+	// TODO: allow retry
+	if err := self.ethereum.AccountManager().Unlock(common.BytesToAddress(addr), pass); err != nil {
+		return false
+	} else {
+		fmt.Println("Account is now unlocked for this session.")
+		return true
+	}
+}
+
+func (self *jsre) exec(filename string) error {
+	if err := self.re.Exec(filename); err != nil {
+		self.re.Stop(false)
+		return fmt.Errorf("Javascript Error: %v", err)
+	}
+	self.re.Stop(true)
+	return nil
+}
+
+func (self *jsre) interactive() {
+	// Read input lines.
+	prompt := make(chan string)
+	inputln := make(chan string)
+	go func() {
+		defer close(inputln)
+		for {
+			line, err := self.Prompt(<-prompt)
+			if err != nil {
+				return
+			}
+			inputln <- line
+		}
+	}()
+	// Wait for Ctrl-C, too.
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, os.Interrupt)
+
+	defer func() {
+		if self.atexit != nil {
+			self.atexit()
+		}
+		self.re.Stop(false)
+	}()
+	for {
+		prompt <- self.ps1
+		select {
+		case <-sig:
+			fmt.Println("caught interrupt, exiting")
+			return
+		case input, ok := <-inputln:
+			if !ok || indentCount <= 0 && input == "exit" {
+				return
+			}
+			if input == "" {
+				continue
+			}
+			str += input + "\n"
+			self.setIndent()
+			if indentCount <= 0 {
+				hist := str[:len(str)-1]
+				self.AppendHistory(hist)
+				self.parseInput(str)
+				str = ""
+			}
+		}
+	}
+}
+
+func (self *jsre) withHistory(op func(*os.File)) {
+	datadir := common.DefaultDataDir()
+	if self.ethereum != nil {
+		datadir = self.ethereum.DataDir
+	}
+
+	hist, err := os.OpenFile(filepath.Join(datadir, "history"), os.O_RDWR|os.O_CREATE, os.ModePerm)
+	if err != nil {
+		fmt.Printf("unable to open history file: %v\n", err)
+		return
+	}
+	op(hist)
+	hist.Close()
+}
+
+func (self *jsre) parseInput(code string) {
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Println("[native] error", r)
+		}
+	}()
+	value, err := self.re.Run(code)
+	if err != nil {
+		if ottoErr, ok := err.(*otto.Error); ok {
+			fmt.Println(ottoErr.String())
+		} else {
+			fmt.Println(err)
+		}
+		return
+	}
+	self.printValue(value)
+}
+
+var indentCount = 0
+var str = ""
+
+func (self *jsre) setIndent() {
+	open := strings.Count(str, "{")
+	open += strings.Count(str, "(")
+	closed := strings.Count(str, "}")
+	closed += strings.Count(str, ")")
+	indentCount = open - closed
+	if indentCount <= 0 {
+		self.ps1 = "> "
+	} else {
+		self.ps1 = strings.Join(make([]string, indentCount*2), "..")
+		self.ps1 += " "
+	}
+}
+
+func (self *jsre) printValue(v interface{}) {
+	val, err := self.re.PrettyPrint(v)
+	if err == nil {
+		fmt.Printf("%v", val)
+	}
+}

cmd/geth/js_test.go

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

cmd/geth/main.go

@@ -0,0 +1,720 @@
+// Copyright 2014 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+// geth is the official command-line client for Ethereum.
+package main
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	_ "net/http/pprof"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/codegangsta/cli"
+	"github.com/ethereum/ethash"
+	"github.com/ethereum/go-ethereum/accounts"
+	"github.com/ethereum/go-ethereum/cmd/utils"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/eth"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/logger/glog"
+	"github.com/ethereum/go-ethereum/metrics"
+	"github.com/ethereum/go-ethereum/rpc/codec"
+	"github.com/ethereum/go-ethereum/rpc/comms"
+	"github.com/mattn/go-colorable"
+	"github.com/mattn/go-isatty"
+)
+
+const (
+	ClientIdentifier = "Geth"
+	Version          = "1.0.0"
+)
+
+var (
+	gitCommit       string // set via linker flag
+	nodeNameVersion string
+	app             *cli.App
+)
+
+func init() {
+	if gitCommit == "" {
+		nodeNameVersion = Version
+	} else {
+		nodeNameVersion = Version + "-" + gitCommit[:8]
+	}
+
+	app = utils.NewApp(Version, "the go-ethereum command line interface")
+	app.Action = run
+	app.HideVersion = true // we have a command to print the version
+	app.Commands = []cli.Command{
+		{
+			Action: blockRecovery,
+			Name:   "recover",
+			Usage:  "attempts to recover a corrupted database by setting a new block by number or hash. See help recover.",
+			Description: `
+The recover commands will attempt to read out the last
+block based on that.
+
+recover #number recovers by number
+recover <hex> recovers by hash
+`,
+		},
+		blocktestCommand,
+		importCommand,
+		exportCommand,
+		upgradedbCommand,
+		removedbCommand,
+		dumpCommand,
+		monitorCommand,
+		{
+			Action: makedag,
+			Name:   "makedag",
+			Usage:  "generate ethash dag (for testing)",
+			Description: `
+The makedag command generates an ethash DAG in /tmp/dag.
+
+This command exists to support the system testing project.
+Regular users do not need to execute it.
+`,
+		},
+		{
+			Action: version,
+			Name:   "version",
+			Usage:  "print ethereum version numbers",
+			Description: `
+The output of this command is supposed to be machine-readable.
+`,
+		},
+
+		{
+			Name:  "wallet",
+			Usage: "ethereum presale wallet",
+			Subcommands: []cli.Command{
+				{
+					Action: importWallet,
+					Name:   "import",
+					Usage:  "import ethereum presale wallet",
+				},
+			},
+			Description: `
+
+    get wallet import /path/to/my/presale.wallet
+
+will prompt for your password and imports your ether presale account.
+It can be used non-interactively with the --password option taking a
+passwordfile as argument containing the wallet password in plaintext.
+
+`},
+		{
+			Action: accountList,
+			Name:   "account",
+			Usage:  "manage accounts",
+			Description: `
+
+Manage accounts lets you create new accounts, list all existing accounts,
+import a private key into a new account.
+
+'            help' shows a list of subcommands or help for one subcommand.
+
+It supports interactive mode, when you are prompted for password as well as
+non-interactive mode where passwords are supplied via a given password file.
+Non-interactive mode is only meant for scripted use on test networks or known
+safe environments.
+
+Make sure you remember the password you gave when creating a new account (with
+either new or import). Without it you are not able to unlock your account.
+
+Note that exporting your key in unencrypted format is NOT supported.
+
+Keys are stored under <DATADIR>/keys.
+It is safe to transfer the entire directory or the individual keys therein
+between ethereum nodes by simply copying.
+Make sure you backup your keys regularly.
+
+In order to use your account to send transactions, you need to unlock them using the
+'--unlock' option. The argument is a comma
+
+And finally. DO NOT FORGET YOUR PASSWORD.
+`,
+			Subcommands: []cli.Command{
+				{
+					Action: accountList,
+					Name:   "list",
+					Usage:  "print account addresses",
+				},
+				{
+					Action: accountCreate,
+					Name:   "new",
+					Usage:  "create a new account",
+					Description: `
+
+    ethereum account new
+
+Creates a new account. Prints the address.
+
+The account is saved in encrypted format, you are prompted for a passphrase.
+
+You must remember this passphrase to unlock your account in the future.
+
+For non-interactive use the passphrase can be specified with the --password flag:
+
+    ethereum --password <passwordfile> account new
+
+Note, this is meant to be used for testing only, it is a bad idea to save your
+password to file or expose in any other way.
+					`,
+				},
+				{
+					Action: accountUpdate,
+					Name:   "update",
+					Usage:  "update an existing account",
+					Description: `
+
+    ethereum account update <address>
+
+Update an existing account.
+
+The account is saved in the newest version in encrypted format, you are prompted
+for a passphrase to unlock the account and another to save the updated file.
+
+This same command can therefore be used to migrate an account of a deprecated
+format to the newest format or change the password for an account.
+
+For non-interactive use the passphrase can be specified with the --password flag:
+
+    ethereum --password <passwordfile> account new
+
+Since only one password can be given, only format update can be performed,
+changing your password is only possible interactively.
+
+Note that account update has the a side effect that the order of your accounts
+changes.
+					`,
+				},
+				{
+					Action: accountImport,
+					Name:   "import",
+					Usage:  "import a private key into a new account",
+					Description: `
+
+    ethereum account import <keyfile>
+
+Imports an unencrypted private key from <keyfile> and creates a new account.
+Prints the address.
+
+The keyfile is assumed to contain an unencrypted private key in hexadecimal format.
+
+The account is saved in encrypted format, you are prompted for a passphrase.
+
+You must remember this passphrase to unlock your account in the future.
+
+For non-interactive use the passphrase can be specified with the -password flag:
+
+    ethereum --password <passwordfile> account import <keyfile>
+
+Note:
+As you can directly copy your encrypted accounts to another ethereum instance,
+this import mechanism is not needed when you transfer an account between
+nodes.
+					`,
+				},
+			},
+		},
+		{
+			Action: console,
+			Name:   "console",
+			Usage:  `Geth Console: interactive JavaScript environment`,
+			Description: `
+The Geth console is an interactive shell for the JavaScript runtime environment
+which exposes a node admin interface as well as the Ðapp JavaScript API.
+See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console
+`},
+		{
+			Action: attach,
+			Name:   "attach",
+			Usage:  `Geth Console: interactive JavaScript environment (connect to node)`,
+			Description: `
+The Geth console is an interactive shell for the JavaScript runtime environment
+which exposes a node admin interface as well as the Ðapp JavaScript API.
+See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console.
+This command allows to open a console on a running geth node.
+`,
+		},
+		{
+			Action: execJSFiles,
+			Name:   "js",
+			Usage:  `executes the given JavaScript files in the Geth JavaScript VM`,
+			Description: `
+The JavaScript VM exposes a node admin interface as well as the Ðapp
+JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console
+`,
+		},
+	}
+	app.Flags = []cli.Flag{
+		utils.IdentityFlag,
+		utils.UnlockedAccountFlag,
+		utils.PasswordFileFlag,
+		utils.GenesisFileFlag,
+		utils.BootnodesFlag,
+		utils.DataDirFlag,
+		utils.BlockchainVersionFlag,
+		utils.CacheFlag,
+		utils.JSpathFlag,
+		utils.ListenPortFlag,
+		utils.MaxPeersFlag,
+		utils.MaxPendingPeersFlag,
+		utils.EtherbaseFlag,
+		utils.GasPriceFlag,
+		utils.MinerThreadsFlag,
+		utils.MiningEnabledFlag,
+		utils.AutoDAGFlag,
+		utils.NATFlag,
+		utils.NatspecEnabledFlag,
+		utils.NoDiscoverFlag,
+		utils.NodeKeyFileFlag,
+		utils.NodeKeyHexFlag,
+		utils.RPCEnabledFlag,
+		utils.RPCListenAddrFlag,
+		utils.RPCPortFlag,
+		utils.RpcApiFlag,
+		utils.IPCDisabledFlag,
+		utils.IPCApiFlag,
+		utils.IPCPathFlag,
+		utils.ExecFlag,
+		utils.WhisperEnabledFlag,
+		utils.VMDebugFlag,
+		utils.NetworkIdFlag,
+		utils.RPCCORSDomainFlag,
+		utils.VerbosityFlag,
+		utils.BacktraceAtFlag,
+		utils.LogToStdErrFlag,
+		utils.LogVModuleFlag,
+		utils.LogFileFlag,
+		utils.LogJSONFlag,
+		utils.PProfEanbledFlag,
+		utils.PProfPortFlag,
+		utils.MetricsEnabledFlag,
+		utils.SolcPathFlag,
+		utils.GpoMinGasPriceFlag,
+		utils.GpoMaxGasPriceFlag,
+		utils.GpoFullBlockRatioFlag,
+		utils.GpobaseStepDownFlag,
+		utils.GpobaseStepUpFlag,
+		utils.GpobaseCorrectionFactorFlag,
+	}
+	app.Before = func(ctx *cli.Context) error {
+		utils.SetupLogger(ctx)
+		if ctx.GlobalBool(utils.PProfEanbledFlag.Name) {
+			utils.StartPProf(ctx)
+		}
+		return nil
+	}
+	// Start system runtime metrics collection
+	go metrics.CollectProcessMetrics(3 * time.Second)
+}
+
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+	defer logger.Flush()
+	if err := app.Run(os.Args); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+func run(ctx *cli.Context) {
+	utils.CheckLegalese(ctx.GlobalString(utils.DataDirFlag.Name))
+
+	cfg := utils.MakeEthConfig(ClientIdentifier, nodeNameVersion, ctx)
+	ethereum, err := eth.New(cfg)
+	if err != nil {
+		utils.Fatalf("%v", err)
+	}
+
+	startEth(ctx, ethereum)
+	// this blocks the thread
+	ethereum.WaitForShutdown()
+}
+
+func attach(ctx *cli.Context) {
+	utils.CheckLegalese(ctx.GlobalString(utils.DataDirFlag.Name))
+
+	// Wrap the standard output with a colorified stream (windows)
+	if isatty.IsTerminal(os.Stdout.Fd()) {
+		if pr, pw, err := os.Pipe(); err == nil {
+			go io.Copy(colorable.NewColorableStdout(), pr)
+			os.Stdout = pw
+		}
+	}
+
+	var client comms.EthereumClient
+	var err error
+	if ctx.Args().Present() {
+		client, err = comms.ClientFromEndpoint(ctx.Args().First(), codec.JSON)
+	} else {
+		cfg := comms.IpcConfig{
+			Endpoint: ctx.GlobalString(utils.IPCPathFlag.Name),
+		}
+		client, err = comms.NewIpcClient(cfg, codec.JSON)
+	}
+
+	if err != nil {
+		utils.Fatalf("Unable to attach to geth node - %v", err)
+	}
+
+	repl := newLightweightJSRE(
+		ctx.GlobalString(utils.JSpathFlag.Name),
+		client,
+		true,
+		nil)
+
+	if ctx.GlobalString(utils.ExecFlag.Name) != "" {
+		repl.batch(ctx.GlobalString(utils.ExecFlag.Name))
+	} else {
+		repl.welcome()
+		repl.interactive()
+	}
+}
+
+func console(ctx *cli.Context) {
+	utils.CheckLegalese(ctx.GlobalString(utils.DataDirFlag.Name))
+
+	// Wrap the standard output with a colorified stream (windows)
+	if isatty.IsTerminal(os.Stdout.Fd()) {
+		if pr, pw, err := os.Pipe(); err == nil {
+			go io.Copy(colorable.NewColorableStdout(), pr)
+			os.Stdout = pw
+		}
+	}
+
+	cfg := utils.MakeEthConfig(ClientIdentifier, nodeNameVersion, ctx)
+	ethereum, err := eth.New(cfg)
+	if err != nil {
+		utils.Fatalf("%v", err)
+	}
+
+	client := comms.NewInProcClient(codec.JSON)
+
+	startEth(ctx, ethereum)
+	repl := newJSRE(
+		ethereum,
+		ctx.GlobalString(utils.JSpathFlag.Name),
+		ctx.GlobalString(utils.RPCCORSDomainFlag.Name),
+		client,
+		true,
+		nil,
+	)
+
+	if ctx.GlobalString(utils.ExecFlag.Name) != "" {
+		repl.batch(ctx.GlobalString(utils.ExecFlag.Name))
+	} else {
+		repl.welcome()
+		repl.interactive()
+	}
+
+	ethereum.Stop()
+	ethereum.WaitForShutdown()
+}
+
+func execJSFiles(ctx *cli.Context) {
+	utils.CheckLegalese(ctx.GlobalString(utils.DataDirFlag.Name))
+
+	cfg := utils.MakeEthConfig(ClientIdentifier, nodeNameVersion, ctx)
+	ethereum, err := eth.New(cfg)
+	if err != nil {
+		utils.Fatalf("%v", err)
+	}
+
+	client := comms.NewInProcClient(codec.JSON)
+	startEth(ctx, ethereum)
+	repl := newJSRE(
+		ethereum,
+		ctx.GlobalString(utils.JSpathFlag.Name),
+		ctx.GlobalString(utils.RPCCORSDomainFlag.Name),
+		client,
+		false,
+		nil,
+	)
+	for _, file := range ctx.Args() {
+		repl.exec(file)
+	}
+
+	ethereum.Stop()
+	ethereum.WaitForShutdown()
+}
+
+func unlockAccount(ctx *cli.Context, am *accounts.Manager, addr string, i int) (addrHex, auth string) {
+	utils.CheckLegalese(ctx.GlobalString(utils.DataDirFlag.Name))
+
+	var err error
+	addrHex, err = utils.ParamToAddress(addr, am)
+	if err == nil {
+		// Attempt to unlock the account 3 times
+		attempts := 3
+		for tries := 0; tries < attempts; tries++ {
+			msg := fmt.Sprintf("Unlocking account %s | Attempt %d/%d", addr, tries+1, attempts)
+			auth = getPassPhrase(ctx, msg, false, i)
+			err = am.Unlock(common.HexToAddress(addrHex), auth)
+			if err == nil {
+				break
+			}
+		}
+	}
+
+	if err != nil {
+		utils.Fatalf("Unlock account failed '%v'", err)
+	}
+	fmt.Printf("Account '%s' unlocked.\n", addr)
+	return
+}
+
+func blockRecovery(ctx *cli.Context) {
+	utils.CheckLegalese(ctx.GlobalString(utils.DataDirFlag.Name))
+
+	arg := ctx.Args().First()
+	if len(ctx.Args()) < 1 && len(arg) > 0 {
+		glog.Fatal("recover requires block number or hash")
+	}
+
+	cfg := utils.MakeEthConfig(ClientIdentifier, nodeNameVersion, ctx)
+	utils.CheckLegalese(cfg.DataDir)
+
+	blockDb, err := ethdb.NewLDBDatabase(filepath.Join(cfg.DataDir, "blockchain"), cfg.DatabaseCache)
+	if err != nil {
+		glog.Fatalln("could not open db:", err)
+	}
+
+	var block *types.Block
+	if arg[0] == '#' {
+		block = core.GetBlockByNumber(blockDb, common.String2Big(arg[1:]).Uint64())
+	} else {
+		block = core.GetBlockByHash(blockDb, common.HexToHash(arg))
+	}
+
+	if block == nil {
+		glog.Fatalln("block not found. Recovery failed")
+	}
+
+	err = core.WriteHead(blockDb, block)
+	if err != nil {
+		glog.Fatalln("block write err", err)
+	}
+	glog.Infof("Recovery succesful. New HEAD %x\n", block.Hash())
+}
+
+func startEth(ctx *cli.Context, eth *eth.Ethereum) {
+	// Start Ethereum itself
+	utils.StartEthereum(eth)
+
+	am := eth.AccountManager()
+	account := ctx.GlobalString(utils.UnlockedAccountFlag.Name)
+	accounts := strings.Split(account, " ")
+	for i, account := range accounts {
+		if len(account) > 0 {
+			if account == "primary" {
+				utils.Fatalf("the 'primary' keyword is deprecated. You can use integer indexes, but the indexes are not permanent, they can change if you add external keys, export your keys or copy your keystore to another node.")
+			}
+			unlockAccount(ctx, am, account, i)
+		}
+	}
+	// Start auxiliary services if enabled.
+	if !ctx.GlobalBool(utils.IPCDisabledFlag.Name) {
+		if err := utils.StartIPC(eth, ctx); err != nil {
+			utils.Fatalf("Error string IPC: %v", err)
+		}
+	}
+	if ctx.GlobalBool(utils.RPCEnabledFlag.Name) {
+		if err := utils.StartRPC(eth, ctx); err != nil {
+			utils.Fatalf("Error starting RPC: %v", err)
+		}
+	}
+	if ctx.GlobalBool(utils.MiningEnabledFlag.Name) {
+		if err := eth.StartMining(ctx.GlobalInt(utils.MinerThreadsFlag.Name)); err != nil {
+			utils.Fatalf("%v", err)
+		}
+	}
+}
+
+func accountList(ctx *cli.Context) {
+	utils.CheckLegalese(ctx.GlobalString(utils.DataDirFlag.Name))
+
+	am := utils.MakeAccountManager(ctx)
+	accts, err := am.Accounts()
+	if err != nil {
+		utils.Fatalf("Could not list accounts: %v", err)
+	}
+	for i, acct := range accts {
+		fmt.Printf("Account #%d: %x\n", i, acct)
+	}
+}
+
+func getPassPhrase(ctx *cli.Context, desc string, confirmation bool, i int) (passphrase string) {
+	passfile := ctx.GlobalString(utils.PasswordFileFlag.Name)
+	if len(passfile) == 0 {
+		fmt.Println(desc)
+		auth, err := utils.PromptPassword("Passphrase: ", true)
+		if err != nil {
+			utils.Fatalf("%v", err)
+		}
+		if confirmation {
+			confirm, err := utils.PromptPassword("Repeat Passphrase: ", false)
+			if err != nil {
+				utils.Fatalf("%v", err)
+			}
+			if auth != confirm {
+				utils.Fatalf("Passphrases did not match.")
+			}
+		}
+		passphrase = auth
+
+	} else {
+		passbytes, err := ioutil.ReadFile(passfile)
+		if err != nil {
+			utils.Fatalf("Unable to read password file '%s': %v", passfile, err)
+		}
+		// this is backwards compatible if the same password unlocks several accounts
+		// it also has the consequence that trailing newlines will not count as part
+		// of the password, so --password <(echo -n 'pass') will now work without -n
+		passphrases := strings.Split(string(passbytes), "\n")
+		if i >= len(passphrases) {
+			passphrase = passphrases[len(passphrases)-1]
+		} else {
+			passphrase = passphrases[i]
+		}
+	}
+	return
+}
+
+func accountCreate(ctx *cli.Context) {
+	utils.CheckLegalese(ctx.GlobalString(utils.DataDirFlag.Name))
+
+	am := utils.MakeAccountManager(ctx)
+	passphrase := getPassPhrase(ctx, "Your new account is locked with a password. Please give a password. Do not forget this password.", true, 0)
+	acct, err := am.NewAccount(passphrase)
+	if err != nil {
+		utils.Fatalf("Could not create the account: %v", err)
+	}
+	fmt.Printf("Address: %x\n", acct)
+}
+
+func accountUpdate(ctx *cli.Context) {
+	utils.CheckLegalese(ctx.GlobalString(utils.DataDirFlag.Name))
+
+	am := utils.MakeAccountManager(ctx)
+	arg := ctx.Args().First()
+	if len(arg) == 0 {
+		utils.Fatalf("account address or index must be given as argument")
+	}
+
+	addr, authFrom := unlockAccount(ctx, am, arg, 0)
+	authTo := getPassPhrase(ctx, "Please give a new password. Do not forget this password.", true, 0)
+	err := am.Update(common.HexToAddress(addr), authFrom, authTo)
+	if err != nil {
+		utils.Fatalf("Could not update the account: %v", err)
+	}
+}
+
+func importWallet(ctx *cli.Context) {
+	utils.CheckLegalese(ctx.GlobalString(utils.DataDirFlag.Name))
+
+	keyfile := ctx.Args().First()
+	if len(keyfile) == 0 {
+		utils.Fatalf("keyfile must be given as argument")
+	}
+	keyJson, err := ioutil.ReadFile(keyfile)
+	if err != nil {
+		utils.Fatalf("Could not read wallet file: %v", err)
+	}
+
+	am := utils.MakeAccountManager(ctx)
+	passphrase := getPassPhrase(ctx, "", false, 0)
+
+	acct, err := am.ImportPreSaleKey(keyJson, passphrase)
+	if err != nil {
+		utils.Fatalf("Could not create the account: %v", err)
+	}
+	fmt.Printf("Address: %x\n", acct)
+}
+
+func accountImport(ctx *cli.Context) {
+	utils.CheckLegalese(ctx.GlobalString(utils.DataDirFlag.Name))
+
+	keyfile := ctx.Args().First()
+	if len(keyfile) == 0 {
+		utils.Fatalf("keyfile must be given as argument")
+	}
+	am := utils.MakeAccountManager(ctx)
+	passphrase := getPassPhrase(ctx, "Your new account is locked with a password. Please give a password. Do not forget this password.", true, 0)
+	acct, err := am.Import(keyfile, passphrase)
+	if err != nil {
+		utils.Fatalf("Could not create the account: %v", err)
+	}
+	fmt.Printf("Address: %x\n", acct)
+}
+
+func makedag(ctx *cli.Context) {
+	utils.CheckLegalese(ctx.GlobalString(utils.DataDirFlag.Name))
+
+	args := ctx.Args()
+	wrongArgs := func() {
+		utils.Fatalf(`Usage: geth makedag <block number> <outputdir>`)
+	}
+	switch {
+	case len(args) == 2:
+		blockNum, err := strconv.ParseUint(args[0], 0, 64)
+		dir := args[1]
+		if err != nil {
+			wrongArgs()
+		} else {
+			dir = filepath.Clean(dir)
+			// seems to require a trailing slash
+			if !strings.HasSuffix(dir, "/") {
+				dir = dir + "/"
+			}
+			_, err = ioutil.ReadDir(dir)
+			if err != nil {
+				utils.Fatalf("Can't find dir")
+			}
+			fmt.Println("making DAG, this could take awhile...")
+			ethash.MakeDAG(blockNum, dir)
+		}
+	default:
+		wrongArgs()
+	}
+}
+
+func version(c *cli.Context) {
+	fmt.Println(ClientIdentifier)
+	fmt.Println("Version:", Version)
+	if gitCommit != "" {
+		fmt.Println("Git Commit:", gitCommit)
+	}
+	fmt.Println("Protocol Versions:", eth.ProtocolVersions)
+	fmt.Println("Network Id:", c.GlobalInt(utils.NetworkIdFlag.Name))
+	fmt.Println("Go Version:", runtime.Version())
+	fmt.Println("OS:", runtime.GOOS)
+	fmt.Printf("GOPATH=%s\n", os.Getenv("GOPATH"))
+	fmt.Printf("GOROOT=%s\n", runtime.GOROOT())
+}

cmd/geth/monitorcmd.go

@@ -0,0 +1,352 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+	"fmt"
+	"math"
+	"reflect"
+	"runtime"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/codegangsta/cli"
+	"github.com/ethereum/go-ethereum/cmd/utils"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/ethereum/go-ethereum/rpc/codec"
+	"github.com/ethereum/go-ethereum/rpc/comms"
+	"github.com/gizak/termui"
+)
+
+var (
+	monitorCommandAttachFlag = cli.StringFlag{
+		Name:  "attach",
+		Value: "ipc:" + common.DefaultIpcPath(),
+		Usage: "API endpoint to attach to",
+	}
+	monitorCommandRowsFlag = cli.IntFlag{
+		Name:  "rows",
+		Value: 5,
+		Usage: "Maximum rows in the chart grid",
+	}
+	monitorCommandRefreshFlag = cli.IntFlag{
+		Name:  "refresh",
+		Value: 3,
+		Usage: "Refresh interval in seconds",
+	}
+	monitorCommand = cli.Command{
+		Action: monitor,
+		Name:   "monitor",
+		Usage:  `Geth Monitor: node metrics monitoring and visualization`,
+		Description: `
+The Geth monitor is a tool to collect and visualize various internal metrics
+gathered by the node, supporting different chart types as well as the capacity
+to display multiple metrics simultaneously.
+`,
+		Flags: []cli.Flag{
+			monitorCommandAttachFlag,
+			monitorCommandRowsFlag,
+			monitorCommandRefreshFlag,
+		},
+	}
+)
+
+// monitor starts a terminal UI based monitoring tool for the requested metrics.
+func monitor(ctx *cli.Context) {
+	var (
+		client comms.EthereumClient
+		err    error
+	)
+	// Attach to an Ethereum node over IPC or RPC
+	endpoint := ctx.String(monitorCommandAttachFlag.Name)
+	if client, err = comms.ClientFromEndpoint(endpoint, codec.JSON); err != nil {
+		utils.Fatalf("Unable to attach to geth node: %v", err)
+	}
+	defer client.Close()
+
+	xeth := rpc.NewXeth(client)
+
+	// Retrieve all the available metrics and resolve the user pattens
+	metrics, err := retrieveMetrics(xeth)
+	if err != nil {
+		utils.Fatalf("Failed to retrieve system metrics: %v", err)
+	}
+	monitored := resolveMetrics(metrics, ctx.Args())
+	if len(monitored) == 0 {
+		list := expandMetrics(metrics, "")
+		sort.Strings(list)
+
+		if len(list) > 0 {
+			utils.Fatalf("No metrics specified.\n\nAvailable:\n - %s", strings.Join(list, "\n - "))
+		} else {
+			utils.Fatalf("No metrics collected by geth (--%s).\n", utils.MetricsEnabledFlag.Name)
+		}
+	}
+	sort.Strings(monitored)
+	if cols := len(monitored) / ctx.Int(monitorCommandRowsFlag.Name); cols > 6 {
+		utils.Fatalf("Requested metrics (%d) spans more that 6 columns:\n - %s", len(monitored), strings.Join(monitored, "\n - "))
+	}
+	// Create and configure the chart UI defaults
+	if err := termui.Init(); err != nil {
+		utils.Fatalf("Unable to initialize terminal UI: %v", err)
+	}
+	defer termui.Close()
+
+	termui.UseTheme("helloworld")
+
+	rows := len(monitored)
+	if max := ctx.Int(monitorCommandRowsFlag.Name); rows > max {
+		rows = max
+	}
+	cols := (len(monitored) + rows - 1) / rows
+	for i := 0; i < rows; i++ {
+		termui.Body.AddRows(termui.NewRow())
+	}
+	// Create each individual data chart
+	footer := termui.NewPar("")
+	footer.HasBorder = true
+	footer.Height = 3
+
+	charts := make([]*termui.LineChart, len(monitored))
+	units := make([]int, len(monitored))
+	data := make([][]float64, len(monitored))
+	for i := 0; i < len(monitored); i++ {
+		charts[i] = createChart((termui.TermHeight() - footer.Height) / rows)
+		row := termui.Body.Rows[i%rows]
+		row.Cols = append(row.Cols, termui.NewCol(12/cols, 0, charts[i]))
+	}
+	termui.Body.AddRows(termui.NewRow(termui.NewCol(12, 0, footer)))
+
+	refreshCharts(xeth, monitored, data, units, charts, ctx, footer)
+	termui.Body.Align()
+	termui.Render(termui.Body)
+
+	// Watch for various system events, and periodically refresh the charts
+	refresh := time.Tick(time.Duration(ctx.Int(monitorCommandRefreshFlag.Name)) * time.Second)
+	for {
+		select {
+		case event := <-termui.EventCh():
+			if event.Type == termui.EventKey && event.Key == termui.KeyCtrlC {
+				return
+			}
+			if event.Type == termui.EventResize {
+				termui.Body.Width = termui.TermWidth()
+				for _, chart := range charts {
+					chart.Height = (termui.TermHeight() - footer.Height) / rows
+				}
+				termui.Body.Align()
+				termui.Render(termui.Body)
+			}
+		case <-refresh:
+			if refreshCharts(xeth, monitored, data, units, charts, ctx, footer) {
+				termui.Body.Align()
+			}
+			termui.Render(termui.Body)
+		}
+	}
+}
+
+// retrieveMetrics contacts the attached geth node and retrieves the entire set
+// of collected system metrics.
+func retrieveMetrics(xeth *rpc.Xeth) (map[string]interface{}, error) {
+	return xeth.Call("debug_metrics", []interface{}{true})
+}
+
+// resolveMetrics takes a list of input metric patterns, and resolves each to one
+// or more canonical metric names.
+func resolveMetrics(metrics map[string]interface{}, patterns []string) []string {
+	res := []string{}
+	for _, pattern := range patterns {
+		res = append(res, resolveMetric(metrics, pattern, "")...)
+	}
+	return res
+}
+
+// resolveMetrics takes a single of input metric pattern, and resolves it to one
+// or more canonical metric names.
+func resolveMetric(metrics map[string]interface{}, pattern string, path string) []string {
+	results := []string{}
+
+	// If a nested metric was requested, recurse optionally branching (via comma)
+	parts := strings.SplitN(pattern, "/", 2)
+	if len(parts) > 1 {
+		for _, variation := range strings.Split(parts[0], ",") {
+			if submetrics, ok := metrics[variation].(map[string]interface{}); !ok {
+				utils.Fatalf("Failed to retrieve system metrics: %s", path+variation)
+				return nil
+			} else {
+				results = append(results, resolveMetric(submetrics, parts[1], path+variation+"/")...)
+			}
+		}
+		return results
+	}
+	// Depending what the last link is, return or expand
+	for _, variation := range strings.Split(pattern, ",") {
+		switch metric := metrics[variation].(type) {
+		case float64:
+			// Final metric value found, return as singleton
+			results = append(results, path+variation)
+
+		case map[string]interface{}:
+			results = append(results, expandMetrics(metric, path+variation+"/")...)
+
+		default:
+			utils.Fatalf("Metric pattern resolved to unexpected type: %v", reflect.TypeOf(metric))
+			return nil
+		}
+	}
+	return results
+}
+
+// expandMetrics expands the entire tree of metrics into a flat list of paths.
+func expandMetrics(metrics map[string]interface{}, path string) []string {
+	// Iterate over all fields and expand individually
+	list := []string{}
+	for name, metric := range metrics {
+		switch metric := metric.(type) {
+		case float64:
+			// Final metric value found, append to list
+			list = append(list, path+name)
+
+		case map[string]interface{}:
+			// Tree of metrics found, expand recursively
+			list = append(list, expandMetrics(metric, path+name+"/")...)
+
+		default:
+			utils.Fatalf("Metric pattern %s resolved to unexpected type: %v", path+name, reflect.TypeOf(metric))
+			return nil
+		}
+	}
+	return list
+}
+
+// fetchMetric iterates over the metrics map and retrieves a specific one.
+func fetchMetric(metrics map[string]interface{}, metric string) float64 {
+	parts, found := strings.Split(metric, "/"), true
+	for _, part := range parts[:len(parts)-1] {
+		metrics, found = metrics[part].(map[string]interface{})
+		if !found {
+			return 0
+		}
+	}
+	if v, ok := metrics[parts[len(parts)-1]].(float64); ok {
+		return v
+	}
+	return 0
+}
+
+// refreshCharts retrieves a next batch of metrics, and inserts all the new
+// values into the active datasets and charts
+func refreshCharts(xeth *rpc.Xeth, metrics []string, data [][]float64, units []int, charts []*termui.LineChart, ctx *cli.Context, footer *termui.Par) (realign bool) {
+	values, err := retrieveMetrics(xeth)
+	for i, metric := range metrics {
+		if len(data) < 512 {
+			data[i] = append([]float64{fetchMetric(values, metric)}, data[i]...)
+		} else {
+			data[i] = append([]float64{fetchMetric(values, metric)}, data[i][:len(data[i])-1]...)
+		}
+		if updateChart(metric, data[i], &units[i], charts[i], err) {
+			realign = true
+		}
+	}
+	updateFooter(ctx, err, footer)
+	return
+}
+
+// updateChart inserts a dataset into a line chart, scaling appropriately as to
+// not display weird labels, also updating the chart label accordingly.
+func updateChart(metric string, data []float64, base *int, chart *termui.LineChart, err error) (realign bool) {
+	dataUnits := []string{"", "K", "M", "G", "T", "E"}
+	timeUnits := []string{"ns", "µs", "ms", "s", "ks", "ms"}
+	colors := []termui.Attribute{termui.ColorBlue, termui.ColorCyan, termui.ColorGreen, termui.ColorYellow, termui.ColorRed, termui.ColorRed}
+
+	// Extract only part of the data that's actually visible
+	if chart.Width*2 < len(data) {
+		data = data[:chart.Width*2]
+	}
+	// Find the maximum value and scale under 1K
+	high := 0.0
+	if len(data) > 0 {
+		high = data[0]
+		for _, value := range data[1:] {
+			high = math.Max(high, value)
+		}
+	}
+	unit, scale := 0, 1.0
+	for high >= 1000 {
+		high, unit, scale = high/1000, unit+1, scale*1000
+	}
+	// If the unit changes, re-create the chart (hack to set max height...)
+	if unit != *base {
+		realign, *base, *chart = true, unit, *createChart(chart.Height)
+	}
+	// Update the chart's data points with the scaled values
+	if cap(chart.Data) < len(data) {
+		chart.Data = make([]float64, len(data))
+	}
+	chart.Data = chart.Data[:len(data)]
+	for i, value := range data {
+		chart.Data[i] = value / scale
+	}
+	// Update the chart's label with the scale units
+	units := dataUnits
+	if strings.Contains(metric, "/Percentiles/") || strings.Contains(metric, "/pauses/") || strings.Contains(metric, "/time/") {
+		units = timeUnits
+	}
+	chart.Border.Label = metric
+	if len(units[unit]) > 0 {
+		chart.Border.Label += " [" + units[unit] + "]"
+	}
+	chart.LineColor = colors[unit] | termui.AttrBold
+	if err != nil {
+		chart.LineColor = termui.ColorRed | termui.AttrBold
+	}
+	return
+}
+
+// createChart creates an empty line chart with the default configs.
+func createChart(height int) *termui.LineChart {
+	chart := termui.NewLineChart()
+	if runtime.GOOS == "windows" {
+		chart.Mode = "dot"
+	}
+	chart.DataLabels = []string{""}
+	chart.Height = height
+	chart.AxesColor = termui.ColorWhite
+	chart.PaddingBottom = -2
+
+	chart.Border.LabelFgColor = chart.Border.FgColor | termui.AttrBold
+	chart.Border.FgColor = chart.Border.BgColor
+
+	return chart
+}
+
+// updateFooter updates the footer contents based on any encountered errors.
+func updateFooter(ctx *cli.Context, err error, footer *termui.Par) {
+	// Generate the basic footer
+	refresh := time.Duration(ctx.Int(monitorCommandRefreshFlag.Name)) * time.Second
+	footer.Text = fmt.Sprintf("Press Ctrl+C to quit. Refresh interval: %v.", refresh)
+	footer.TextFgColor = termui.Theme().ParTextFg | termui.AttrBold
+
+	// Append any encountered errors
+	if err != nil {
+		footer.Text = fmt.Sprintf("Error: %v.", err)
+		footer.TextFgColor = termui.ColorRed | termui.AttrBold
+	}
+}

cmd/rlpdump/main.go

@@ -0,0 +1,143 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+// rlpdump is a pretty-printer for RLP data.
+package main
+
+import (
+	"bytes"
+	"encoding/hex"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/rlp"
+)
+
+var (
+	hexMode = flag.String("hex", "", "dump given hex data")
+	noASCII = flag.Bool("noascii", false, "don't print ASCII strings readably")
+)
+
+func init() {
+	flag.Usage = func() {
+		fmt.Fprintln(os.Stderr, "Usage:", os.Args[0], "[-noascii] [-hex <data>] [filename]")
+		flag.PrintDefaults()
+		fmt.Fprintln(os.Stderr, `
+Dumps RLP data from the given file in readable form.
+If the filename is omitted, data is read from stdin.`)
+	}
+}
+
+func main() {
+	flag.Parse()
+
+	var r io.Reader
+	switch {
+	case *hexMode != "":
+		data, err := hex.DecodeString(*hexMode)
+		if err != nil {
+			die(err)
+		}
+		r = bytes.NewReader(data)
+
+	case flag.NArg() == 0:
+		r = os.Stdin
+
+	case flag.NArg() == 1:
+		fd, err := os.Open(flag.Arg(0))
+		if err != nil {
+			die(err)
+		}
+		defer fd.Close()
+		r = fd
+
+	default:
+		fmt.Fprintln(os.Stderr, "Error: too many arguments")
+		flag.Usage()
+		os.Exit(2)
+	}
+
+	s := rlp.NewStream(r, 0)
+	for {
+		if err := dump(s, 0); err != nil {
+			if err != io.EOF {
+				die(err)
+			}
+			break
+		}
+		fmt.Println()
+	}
+}
+
+func dump(s *rlp.Stream, depth int) error {
+	kind, size, err := s.Kind()
+	if err != nil {
+		return err
+	}
+	switch kind {
+	case rlp.Byte, rlp.String:
+		str, err := s.Bytes()
+		if err != nil {
+			return err
+		}
+		if len(str) == 0 || !*noASCII && isASCII(str) {
+			fmt.Printf("%s%q", ws(depth), str)
+		} else {
+			fmt.Printf("%s%x", ws(depth), str)
+		}
+	case rlp.List:
+		s.List()
+		defer s.ListEnd()
+		if size == 0 {
+			fmt.Print(ws(depth) + "[]")
+		} else {
+			fmt.Println(ws(depth) + "[")
+			for i := 0; ; i++ {
+				if i > 0 {
+					fmt.Print(",\n")
+				}
+				if err := dump(s, depth+1); err == rlp.EOL {
+					break
+				} else if err != nil {
+					return err
+				}
+			}
+			fmt.Print(ws(depth) + "]")
+		}
+	}
+	return nil
+}
+
+func isASCII(b []byte) bool {
+	for _, c := range b {
+		if c < 32 || c > 126 {
+			return false
+		}
+	}
+	return true
+}
+
+func ws(n int) string {
+	return strings.Repeat("  ", n)
+}
+
+func die(args ...interface{}) {
+	fmt.Fprintln(os.Stderr, args...)
+	os.Exit(1)
+}

cmd/utils/cmd.go

@@ -0,0 +1,264 @@
+// Copyright 2014 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+// Package utils contains internal helper functions for go-ethereum commands.
+package utils
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"os/signal"
+	"regexp"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/eth"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/logger/glog"
+	"github.com/ethereum/go-ethereum/rlp"
+	"github.com/peterh/liner"
+)
+
+const (
+	importBatchSize = 2500
+)
+
+var interruptCallbacks = []func(os.Signal){}
+
+func openLogFile(Datadir string, filename string) *os.File {
+	path := common.AbsolutePath(Datadir, filename)
+	file, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
+	if err != nil {
+		panic(fmt.Sprintf("error opening log file '%s': %v", filename, err))
+	}
+	return file
+}
+
+func PromptConfirm(prompt string) (bool, error) {
+	var (
+		input string
+		err   error
+	)
+	prompt = prompt + " [y/N] "
+
+	// if liner.TerminalSupported() {
+	// 	fmt.Println("term")
+	// 	lr := liner.NewLiner()
+	// 	defer lr.Close()
+	// 	input, err = lr.Prompt(prompt)
+	// } else {
+	fmt.Print(prompt)
+	input, err = bufio.NewReader(os.Stdin).ReadString('\n')
+	fmt.Println()
+	// }
+
+	if len(input) > 0 && strings.ToUpper(input[:1]) == "Y" {
+		return true, nil
+	} else {
+		return false, nil
+	}
+
+	return false, err
+}
+
+func PromptPassword(prompt string, warnTerm bool) (string, error) {
+	if liner.TerminalSupported() {
+		lr := liner.NewLiner()
+		defer lr.Close()
+		return lr.PasswordPrompt(prompt)
+	}
+	if warnTerm {
+		fmt.Println("!! Unsupported terminal, password will be echoed.")
+	}
+	fmt.Print(prompt)
+	input, err := bufio.NewReader(os.Stdin).ReadString('\n')
+	fmt.Println()
+	return input, err
+}
+
+func CheckLegalese(datadir string) {
+	// check "first run"
+	if !common.FileExist(datadir) {
+		r, _ := PromptConfirm(legalese)
+		if !r {
+			Fatalf("Must accept to continue. Shutting down...\n")
+		}
+	}
+}
+
+// Fatalf formats a message to standard error and exits the program.
+// The message is also printed to standard output if standard error
+// is redirected to a different file.
+func Fatalf(format string, args ...interface{}) {
+	w := io.MultiWriter(os.Stdout, os.Stderr)
+	outf, _ := os.Stdout.Stat()
+	errf, _ := os.Stderr.Stat()
+	if outf != nil && errf != nil && os.SameFile(outf, errf) {
+		w = os.Stderr
+	}
+	fmt.Fprintf(w, "Fatal: "+format+"\n", args...)
+	logger.Flush()
+	os.Exit(1)
+}
+
+func StartEthereum(ethereum *eth.Ethereum) {
+	glog.V(logger.Info).Infoln("Starting", ethereum.Name())
+	if err := ethereum.Start(); err != nil {
+		Fatalf("Error starting Ethereum: %v", err)
+	}
+	go func() {
+		sigc := make(chan os.Signal, 1)
+		signal.Notify(sigc, os.Interrupt)
+		defer signal.Stop(sigc)
+		<-sigc
+		glog.V(logger.Info).Infoln("Got interrupt, shutting down...")
+		go ethereum.Stop()
+		logger.Flush()
+		for i := 10; i > 0; i-- {
+			<-sigc
+			if i > 1 {
+				glog.V(logger.Info).Infoln("Already shutting down, please be patient.")
+				glog.V(logger.Info).Infoln("Interrupt", i-1, "more times to induce panic.")
+			}
+		}
+		glog.V(logger.Error).Infof("Force quitting: this might not end so well.")
+		panic("boom")
+	}()
+}
+
+func FormatTransactionData(data string) []byte {
+	d := common.StringToByteFunc(data, func(s string) (ret []byte) {
+		slice := regexp.MustCompile("\\n|\\s").Split(s, 1000000000)
+		for _, dataItem := range slice {
+			d := common.FormatData(dataItem)
+			ret = append(ret, d...)
+		}
+		return
+	})
+
+	return d
+}
+
+func ImportChain(chain *core.ChainManager, fn string) error {
+	// Watch for Ctrl-C while the import is running.
+	// If a signal is received, the import will stop at the next batch.
+	interrupt := make(chan os.Signal, 1)
+	stop := make(chan struct{})
+	signal.Notify(interrupt, os.Interrupt)
+	defer signal.Stop(interrupt)
+	defer close(interrupt)
+	go func() {
+		if _, ok := <-interrupt; ok {
+			glog.Info("caught interrupt during import, will stop at next batch")
+		}
+		close(stop)
+	}()
+	checkInterrupt := func() bool {
+		select {
+		case <-stop:
+			return true
+		default:
+			return false
+		}
+	}
+
+	glog.Infoln("Importing blockchain", fn)
+	fh, err := os.Open(fn)
+	if err != nil {
+		return err
+	}
+	defer fh.Close()
+	stream := rlp.NewStream(fh, 0)
+
+	// Run actual the import.
+	blocks := make(types.Blocks, importBatchSize)
+	n := 0
+	for batch := 0; ; batch++ {
+		// Load a batch of RLP blocks.
+		if checkInterrupt() {
+			return fmt.Errorf("interrupted")
+		}
+		i := 0
+		for ; i < importBatchSize; i++ {
+			var b types.Block
+			if err := stream.Decode(&b); err == io.EOF {
+				break
+			} else if err != nil {
+				return fmt.Errorf("at block %d: %v", n, err)
+			}
+			blocks[i] = &b
+			n++
+		}
+		if i == 0 {
+			break
+		}
+		// Import the batch.
+		if checkInterrupt() {
+			return fmt.Errorf("interrupted")
+		}
+		if hasAllBlocks(chain, blocks[:i]) {
+			glog.Infof("skipping batch %d, all blocks present [%x / %x]",
+				batch, blocks[0].Hash().Bytes()[:4], blocks[i-1].Hash().Bytes()[:4])
+			continue
+		}
+		if _, err := chain.InsertChain(blocks[:i]); err != nil {
+			return fmt.Errorf("invalid block %d: %v", n, err)
+		}
+	}
+	return nil
+}
+
+func hasAllBlocks(chain *core.ChainManager, bs []*types.Block) bool {
+	for _, b := range bs {
+		if !chain.HasBlock(b.Hash()) {
+			return false
+		}
+	}
+	return true
+}
+
+func ExportChain(chainmgr *core.ChainManager, fn string) error {
+	glog.Infoln("Exporting blockchain to", fn)
+	fh, err := os.OpenFile(fn, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.ModePerm)
+	if err != nil {
+		return err
+	}
+	defer fh.Close()
+	if err := chainmgr.Export(fh); err != nil {
+		return err
+	}
+	glog.Infoln("Exported blockchain to", fn)
+	return nil
+}
+
+func ExportAppendChain(chainmgr *core.ChainManager, fn string, first uint64, last uint64) error {
+	glog.Infoln("Exporting blockchain to", fn)
+	// TODO verify mode perms
+	fh, err := os.OpenFile(fn, os.O_CREATE|os.O_APPEND|os.O_WRONLY, os.ModePerm)
+	if err != nil {
+		return err
+	}
+	defer fh.Close()
+	if err := chainmgr.ExportN(fh, first, last); err != nil {
+		return err
+	}
+	glog.Infoln("Exported blockchain to", fn)
+	return nil
+}

cmd/utils/customflags.go

@@ -0,0 +1,148 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package utils
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"os/user"
+	"path/filepath"
+	"strings"
+
+	"github.com/codegangsta/cli"
+)
+
+// Custom type which is registered in the flags library which cli uses for
+// argument parsing. This allows us to expand Value to an absolute path when
+// the argument is parsed
+type DirectoryString struct {
+	Value string
+}
+
+func (self *DirectoryString) String() string {
+	return self.Value
+}
+
+func (self *DirectoryString) Set(value string) error {
+	self.Value = expandPath(value)
+	return nil
+}
+
+// Custom cli.Flag type which expand the received string to an absolute path.
+// e.g. ~/.ethereum -> /home/username/.ethereum
+type DirectoryFlag struct {
+	cli.GenericFlag
+	Name   string
+	Value  DirectoryString
+	Usage  string
+	EnvVar string
+}
+
+func (self DirectoryFlag) String() string {
+	var fmtString string
+	fmtString = "%s %v\t%v"
+
+	if len(self.Value.Value) > 0 {
+		fmtString = "%s \"%v\"\t%v"
+	} else {
+		fmtString = "%s %v\t%v"
+	}
+
+	return withEnvHint(self.EnvVar, fmt.Sprintf(fmtString, prefixedNames(self.Name), self.Value.Value, self.Usage))
+}
+
+func eachName(longName string, fn func(string)) {
+	parts := strings.Split(longName, ",")
+	for _, name := range parts {
+		name = strings.Trim(name, " ")
+		fn(name)
+	}
+}
+
+// called by cli library, grabs variable from environment (if in env)
+// and adds variable to flag set for parsing.
+func (self DirectoryFlag) Apply(set *flag.FlagSet) {
+	if self.EnvVar != "" {
+		for _, envVar := range strings.Split(self.EnvVar, ",") {
+			envVar = strings.TrimSpace(envVar)
+			if envVal := os.Getenv(envVar); envVal != "" {
+				self.Value.Value = envVal
+				break
+			}
+		}
+	}
+
+	eachName(self.Name, func(name string) {
+		set.Var(&self.Value, self.Name, self.Usage)
+	})
+}
+
+func prefixFor(name string) (prefix string) {
+	if len(name) == 1 {
+		prefix = "-"
+	} else {
+		prefix = "--"
+	}
+
+	return
+}
+
+func prefixedNames(fullName string) (prefixed string) {
+	parts := strings.Split(fullName, ",")
+	for i, name := range parts {
+		name = strings.Trim(name, " ")
+		prefixed += prefixFor(name) + name
+		if i < len(parts)-1 {
+			prefixed += ", "
+		}
+	}
+	return
+}
+
+func withEnvHint(envVar, str string) string {
+	envText := ""
+	if envVar != "" {
+		envText = fmt.Sprintf(" [$%s]", strings.Join(strings.Split(envVar, ","), ", $"))
+	}
+	return str + envText
+}
+
+func (self DirectoryFlag) getName() string {
+	return self.Name
+}
+
+func (self *DirectoryFlag) Set(value string) {
+	self.Value.Value = value
+}
+
+// Expands a file path
+// 1. replace tilde with users home dir
+// 2. expands embedded environment variables
+// 3. cleans the path, e.g. /a/b/../c -> /a/c
+// Note, it has limitations, e.g. ~someuser/tmp will not be expanded
+func expandPath(p string) string {
+	if strings.HasPrefix(p, "~/") || strings.HasPrefix(p, "~\\") {
+		if user, err := user.Current(); err == nil {
+			if err == nil {
+				p = strings.Replace(p, "~", user.HomeDir, 1)
+			}
+		}
+	}
+
+	return filepath.Clean(os.ExpandEnv(p))
+}

cmd/utils/customflags_test.go

@@ -0,0 +1,44 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package utils
+
+import (
+	"os"
+	"os/user"
+	"testing"
+)
+
+func TestPathExpansion(t *testing.T) {
+
+	user, _ := user.Current()
+
+	tests := map[string]string{
+		"/home/someuser/tmp": "/home/someuser/tmp",
+		"~/tmp":              user.HomeDir + "/tmp",
+		"$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 {
+			t.Errorf("test %s, got %s, expected %s\n", test, got, expected)
+		}
+	}
+}

cmd/utils/flags.go

@@ -0,0 +1,543 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package utils
+
+import (
+	"crypto/ecdsa"
+	"fmt"
+	"log"
+	"math/big"
+	"net/http"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strconv"
+
+	"github.com/ethereum/go-ethereum/metrics"
+
+	"github.com/codegangsta/cli"
+	"github.com/ethereum/ethash"
+	"github.com/ethereum/go-ethereum/accounts"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/eth"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/event"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/logger/glog"
+	"github.com/ethereum/go-ethereum/p2p/nat"
+	"github.com/ethereum/go-ethereum/rpc/api"
+	"github.com/ethereum/go-ethereum/rpc/codec"
+	"github.com/ethereum/go-ethereum/rpc/comms"
+	"github.com/ethereum/go-ethereum/xeth"
+)
+
+func init() {
+	cli.AppHelpTemplate = `{{.Name}} {{if .Flags}}[global options] {{end}}command{{if .Flags}} [command options]{{end}} [arguments...]
+
+VERSION:
+   {{.Version}}
+
+COMMANDS:
+   {{range .Commands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}
+   {{end}}{{if .Flags}}
+GLOBAL OPTIONS:
+   {{range .Flags}}{{.}}
+   {{end}}{{end}}
+`
+
+	cli.CommandHelpTemplate = `{{.Name}}{{if .Subcommands}} command{{end}}{{if .Flags}} [command options]{{end}} [arguments...]
+{{if .Description}}{{.Description}}
+{{end}}{{if .Subcommands}}
+SUBCOMMANDS:
+	{{range .Subcommands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}
+	{{end}}{{end}}{{if .Flags}}
+OPTIONS:
+	{{range .Flags}}{{.}}
+	{{end}}{{end}}
+`
+}
+
+// NewApp creates an app with sane defaults.
+func NewApp(version, usage string) *cli.App {
+	app := cli.NewApp()
+	app.Name = filepath.Base(os.Args[0])
+	app.Author = ""
+	//app.Authors = nil
+	app.Email = ""
+	app.Version = version
+	app.Usage = usage
+	return app
+}
+
+// These are all the command line flags we support.
+// If you add to this list, please remember to include the
+// flag in the appropriate command definition.
+//
+// The flags are defined here so their names and help texts
+// are the same for all commands.
+
+var (
+	// General settings
+	DataDirFlag = DirectoryFlag{
+		Name:  "datadir",
+		Usage: "Data directory to be used",
+		Value: DirectoryString{common.DefaultDataDir()},
+	}
+	NetworkIdFlag = cli.IntFlag{
+		Name:  "networkid",
+		Usage: "Network Id (integer)",
+		Value: eth.NetworkId,
+	}
+	BlockchainVersionFlag = cli.IntFlag{
+		Name:  "blockchainversion",
+		Usage: "Blockchain version (integer)",
+		Value: core.BlockChainVersion,
+	}
+	GenesisNonceFlag = cli.IntFlag{
+		Name:  "genesisnonce",
+		Usage: "Sets the genesis nonce",
+		Value: 42,
+	}
+	GenesisFileFlag = cli.StringFlag{
+		Name:  "genesis",
+		Usage: "Inserts/Overwrites the genesis block (json format)",
+	}
+	IdentityFlag = cli.StringFlag{
+		Name:  "identity",
+		Usage: "Custom node name",
+	}
+	NatspecEnabledFlag = cli.BoolFlag{
+		Name:  "natspec",
+		Usage: "Enable NatSpec confirmation notice",
+	}
+	CacheFlag = cli.IntFlag{
+		Name:  "cache",
+		Usage: "Megabytes of memory allocated to internal caching",
+		Value: 0,
+	}
+
+	// miner settings
+	MinerThreadsFlag = cli.IntFlag{
+		Name:  "minerthreads",
+		Usage: "Number of miner threads",
+		Value: runtime.NumCPU(),
+	}
+	MiningEnabledFlag = cli.BoolFlag{
+		Name:  "mine",
+		Usage: "Enable mining",
+	}
+	AutoDAGFlag = cli.BoolFlag{
+		Name:  "autodag",
+		Usage: "Enable automatic DAG pregeneration",
+	}
+	EtherbaseFlag = cli.StringFlag{
+		Name:  "etherbase",
+		Usage: "Public address for block mining rewards. By default the address first created is used",
+		Value: "0",
+	}
+	GasPriceFlag = cli.StringFlag{
+		Name:  "gasprice",
+		Usage: "Sets the minimal gasprice when mining transactions",
+		Value: new(big.Int).Mul(big.NewInt(500), common.Shannon).String(),
+	}
+
+	UnlockedAccountFlag = cli.StringFlag{
+		Name:  "unlock",
+		Usage: "Unlock the account given until this program exits (prompts for password). '--unlock n' unlocks the n-th account in order or creation.",
+		Value: "",
+	}
+	PasswordFileFlag = cli.StringFlag{
+		Name:  "password",
+		Usage: "Path to password file to use with options and subcommands needing a password",
+		Value: "",
+	}
+
+	// logging and debug settings
+	LogFileFlag = cli.StringFlag{
+		Name:  "logfile",
+		Usage: "Send log output to a file",
+	}
+	VerbosityFlag = cli.IntFlag{
+		Name:  "verbosity",
+		Usage: "Logging verbosity: 0-6 (0=silent, 1=error, 2=warn, 3=info, 4=core, 5=debug, 6=debug detail)",
+		Value: int(logger.InfoLevel),
+	}
+	LogJSONFlag = cli.StringFlag{
+		Name:  "logjson",
+		Usage: "Send json structured log output to a file or '-' for standard output (default: no json output)",
+		Value: "",
+	}
+	LogToStdErrFlag = cli.BoolFlag{
+		Name:  "logtostderr",
+		Usage: "Logs are written to standard error instead of to files.",
+	}
+	LogVModuleFlag = cli.GenericFlag{
+		Name:  "vmodule",
+		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",
+		Value: glog.GetTraceLocation(),
+	}
+	PProfEanbledFlag = cli.BoolFlag{
+		Name:  "pprof",
+		Usage: "Enable the profiling server on localhost",
+	}
+	PProfPortFlag = cli.IntFlag{
+		Name:  "pprofport",
+		Usage: "Port on which the profiler should listen",
+		Value: 6060,
+	}
+	MetricsEnabledFlag = cli.BoolFlag{
+		Name:  metrics.MetricsEnabledFlag,
+		Usage: "Enables metrics collection and reporting",
+	}
+
+	// RPC settings
+	RPCEnabledFlag = cli.BoolFlag{
+		Name:  "rpc",
+		Usage: "Enable the JSON-RPC server",
+	}
+	RPCListenAddrFlag = cli.StringFlag{
+		Name:  "rpcaddr",
+		Usage: "Listening address for the JSON-RPC server",
+		Value: "127.0.0.1",
+	}
+	RPCPortFlag = cli.IntFlag{
+		Name:  "rpcport",
+		Usage: "Port on which the JSON-RPC server should listen",
+		Value: 8545,
+	}
+	RPCCORSDomainFlag = cli.StringFlag{
+		Name:  "rpccorsdomain",
+		Usage: "Domain on which to send Access-Control-Allow-Origin header",
+		Value: "",
+	}
+	RpcApiFlag = cli.StringFlag{
+		Name:  "rpcapi",
+		Usage: "Specify the API's which are offered over the HTTP RPC interface",
+		Value: comms.DefaultHttpRpcApis,
+	}
+	IPCDisabledFlag = cli.BoolFlag{
+		Name:  "ipcdisable",
+		Usage: "Disable the IPC-RPC server",
+	}
+	IPCApiFlag = cli.StringFlag{
+		Name:  "ipcapi",
+		Usage: "Specify the API's which are offered over the IPC interface",
+		Value: comms.DefaultIpcApis,
+	}
+	IPCPathFlag = DirectoryFlag{
+		Name:  "ipcpath",
+		Usage: "Filename for IPC socket/pipe",
+		Value: DirectoryString{common.DefaultIpcPath()},
+	}
+	ExecFlag = cli.StringFlag{
+		Name:  "exec",
+		Usage: "Execute javascript statement (only in combination with console/attach)",
+	}
+	// Network Settings
+	MaxPeersFlag = cli.IntFlag{
+		Name:  "maxpeers",
+		Usage: "Maximum number of network peers (network disabled if set to 0)",
+		Value: 25,
+	}
+	MaxPendingPeersFlag = cli.IntFlag{
+		Name:  "maxpendpeers",
+		Usage: "Maximum number of pending connection attempts (defaults used if set to 0)",
+		Value: 0,
+	}
+	ListenPortFlag = cli.IntFlag{
+		Name:  "port",
+		Usage: "Network listening port",
+		Value: 30303,
+	}
+	BootnodesFlag = cli.StringFlag{
+		Name:  "bootnodes",
+		Usage: "Space-separated enode URLs for p2p discovery bootstrap",
+		Value: "",
+	}
+	NodeKeyFileFlag = cli.StringFlag{
+		Name:  "nodekey",
+		Usage: "P2P node key file",
+	}
+	NodeKeyHexFlag = cli.StringFlag{
+		Name:  "nodekeyhex",
+		Usage: "P2P node key as hex (for testing)",
+	}
+	NATFlag = cli.StringFlag{
+		Name:  "nat",
+		Usage: "NAT port mapping mechanism (any|none|upnp|pmp|extip:<IP>)",
+		Value: "any",
+	}
+	NoDiscoverFlag = cli.BoolFlag{
+		Name:  "nodiscover",
+		Usage: "Disables the peer discovery mechanism (manual peer addition)",
+	}
+	WhisperEnabledFlag = cli.BoolFlag{
+		Name:  "shh",
+		Usage: "Enable whisper",
+	}
+	// ATM the url is left to the user and deployment to
+	JSpathFlag = cli.StringFlag{
+		Name:  "jspath",
+		Usage: "JS library path to be used with console and js subcommands",
+		Value: ".",
+	}
+	SolcPathFlag = cli.StringFlag{
+		Name:  "solc",
+		Usage: "solidity compiler to be used",
+		Value: "solc",
+	}
+	GpoMinGasPriceFlag = cli.StringFlag{
+		Name:  "gpomin",
+		Usage: "Minimum suggested gas price",
+		Value: new(big.Int).Mul(big.NewInt(1), common.Szabo).String(),
+	}
+	GpoMaxGasPriceFlag = cli.StringFlag{
+		Name:  "gpomax",
+		Usage: "Maximum suggested gas price",
+		Value: new(big.Int).Mul(big.NewInt(100), common.Szabo).String(),
+	}
+	GpoFullBlockRatioFlag = cli.IntFlag{
+		Name:  "gpofull",
+		Usage: "Full block threshold for gas price calculation (%)",
+		Value: 80,
+	}
+	GpobaseStepDownFlag = cli.IntFlag{
+		Name:  "gpobasedown",
+		Usage: "Suggested gas price base step down ratio (1/1000)",
+		Value: 10,
+	}
+	GpobaseStepUpFlag = cli.IntFlag{
+		Name:  "gpobaseup",
+		Usage: "Suggested gas price base step up ratio (1/1000)",
+		Value: 100,
+	}
+	GpobaseCorrectionFactorFlag = cli.IntFlag{
+		Name:  "gpobasecf",
+		Usage: "Suggested gas price base correction factor (%)",
+		Value: 110,
+	}
+)
+
+// MakeNAT creates a port mapper from set command line flags.
+func MakeNAT(ctx *cli.Context) nat.Interface {
+	natif, err := nat.Parse(ctx.GlobalString(NATFlag.Name))
+	if err != nil {
+		Fatalf("Option %s: %v", NATFlag.Name, err)
+	}
+	return natif
+}
+
+// MakeNodeKey creates a node key from set command line flags.
+func MakeNodeKey(ctx *cli.Context) (key *ecdsa.PrivateKey) {
+	hex, file := ctx.GlobalString(NodeKeyHexFlag.Name), ctx.GlobalString(NodeKeyFileFlag.Name)
+	var err error
+	switch {
+	case file != "" && hex != "":
+		Fatalf("Options %q and %q are mutually exclusive", NodeKeyFileFlag.Name, NodeKeyHexFlag.Name)
+	case file != "":
+		if key, err = crypto.LoadECDSA(file); err != nil {
+			Fatalf("Option %q: %v", NodeKeyFileFlag.Name, err)
+		}
+	case hex != "":
+		if key, err = crypto.HexToECDSA(hex); err != nil {
+			Fatalf("Option %q: %v", NodeKeyHexFlag.Name, err)
+		}
+	}
+	return key
+}
+
+// MakeEthConfig creates ethereum options from set command line flags.
+func MakeEthConfig(clientID, version string, ctx *cli.Context) *eth.Config {
+	customName := ctx.GlobalString(IdentityFlag.Name)
+	if len(customName) > 0 {
+		clientID += "/" + customName
+	}
+	am := MakeAccountManager(ctx)
+	etherbase, err := ParamToAddress(ctx.GlobalString(EtherbaseFlag.Name), am)
+	if err != nil {
+		glog.V(logger.Error).Infoln("WARNING: No etherbase set and no accounts found as default")
+	}
+
+	return &eth.Config{
+		Name:                    common.MakeName(clientID, version),
+		DataDir:                 ctx.GlobalString(DataDirFlag.Name),
+		GenesisNonce:            ctx.GlobalInt(GenesisNonceFlag.Name),
+		GenesisFile:             ctx.GlobalString(GenesisFileFlag.Name),
+		BlockChainVersion:       ctx.GlobalInt(BlockchainVersionFlag.Name),
+		DatabaseCache:           ctx.GlobalInt(CacheFlag.Name),
+		SkipBcVersionCheck:      false,
+		NetworkId:               ctx.GlobalInt(NetworkIdFlag.Name),
+		LogFile:                 ctx.GlobalString(LogFileFlag.Name),
+		Verbosity:               ctx.GlobalInt(VerbosityFlag.Name),
+		LogJSON:                 ctx.GlobalString(LogJSONFlag.Name),
+		Etherbase:               common.HexToAddress(etherbase),
+		MinerThreads:            ctx.GlobalInt(MinerThreadsFlag.Name),
+		AccountManager:          am,
+		VmDebug:                 ctx.GlobalBool(VMDebugFlag.Name),
+		MaxPeers:                ctx.GlobalInt(MaxPeersFlag.Name),
+		MaxPendingPeers:         ctx.GlobalInt(MaxPendingPeersFlag.Name),
+		Port:                    ctx.GlobalString(ListenPortFlag.Name),
+		NAT:                     MakeNAT(ctx),
+		NatSpec:                 ctx.GlobalBool(NatspecEnabledFlag.Name),
+		Discovery:               !ctx.GlobalBool(NoDiscoverFlag.Name),
+		NodeKey:                 MakeNodeKey(ctx),
+		Shh:                     ctx.GlobalBool(WhisperEnabledFlag.Name),
+		Dial:                    true,
+		BootNodes:               ctx.GlobalString(BootnodesFlag.Name),
+		GasPrice:                common.String2Big(ctx.GlobalString(GasPriceFlag.Name)),
+		GpoMinGasPrice:          common.String2Big(ctx.GlobalString(GpoMinGasPriceFlag.Name)),
+		GpoMaxGasPrice:          common.String2Big(ctx.GlobalString(GpoMaxGasPriceFlag.Name)),
+		GpoFullBlockRatio:       ctx.GlobalInt(GpoFullBlockRatioFlag.Name),
+		GpobaseStepDown:         ctx.GlobalInt(GpobaseStepDownFlag.Name),
+		GpobaseStepUp:           ctx.GlobalInt(GpobaseStepUpFlag.Name),
+		GpobaseCorrectionFactor: ctx.GlobalInt(GpobaseCorrectionFactorFlag.Name),
+		SolcPath:                ctx.GlobalString(SolcPathFlag.Name),
+		AutoDAG:                 ctx.GlobalBool(AutoDAGFlag.Name) || ctx.GlobalBool(MiningEnabledFlag.Name),
+	}
+}
+
+// SetupLogger configures glog from the logging-related command line flags.
+func SetupLogger(ctx *cli.Context) {
+	glog.SetV(ctx.GlobalInt(VerbosityFlag.Name))
+	glog.CopyStandardLogTo("INFO")
+	glog.SetToStderr(true)
+	glog.SetLogDir(ctx.GlobalString(LogFileFlag.Name))
+}
+
+// MakeChain creates a chain manager from set command line flags.
+func MakeChain(ctx *cli.Context) (chain *core.ChainManager, blockDB, stateDB, extraDB 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 {
+		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)
+	}
+
+	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)
+	if err != nil {
+		Fatalf("Could not start chainmanager: %v", err)
+	}
+
+	proc := core.NewBlockProcessor(stateDB, extraDB, pow, chain, eventMux)
+	chain.SetProcessor(proc)
+	return chain, blockDB, stateDB, extraDB
+}
+
+// MakeChain creates an account manager from set command line flags.
+func MakeAccountManager(ctx *cli.Context) *accounts.Manager {
+	dataDir := ctx.GlobalString(DataDirFlag.Name)
+	ks := crypto.NewKeyStorePassphrase(filepath.Join(dataDir, "keystore"))
+	return accounts.NewManager(ks)
+}
+
+func IpcSocketPath(ctx *cli.Context) (ipcpath string) {
+	if common.IsWindows() {
+		ipcpath = common.DefaultIpcPath()
+		if ctx.GlobalIsSet(IPCPathFlag.Name) {
+			ipcpath = ctx.GlobalString(IPCPathFlag.Name)
+		}
+	} else {
+		ipcpath = common.DefaultIpcPath()
+		if ctx.GlobalIsSet(DataDirFlag.Name) {
+			ipcpath = filepath.Join(ctx.GlobalString(DataDirFlag.Name), "geth.ipc")
+		}
+		if ctx.GlobalIsSet(IPCPathFlag.Name) {
+			ipcpath = ctx.GlobalString(IPCPathFlag.Name)
+		}
+	}
+
+	return
+}
+
+func StartIPC(eth *eth.Ethereum, ctx *cli.Context) error {
+	config := comms.IpcConfig{
+		Endpoint: IpcSocketPath(ctx),
+	}
+
+	xeth := xeth.New(eth, nil)
+	codec := codec.JSON
+
+	apis, err := api.ParseApiString(ctx.GlobalString(IPCApiFlag.Name), codec, xeth, eth)
+	if err != nil {
+		return err
+	}
+
+	return comms.StartIpc(config, codec, api.Merge(apis...))
+}
+
+func StartRPC(eth *eth.Ethereum, ctx *cli.Context) error {
+	config := comms.HttpConfig{
+		ListenAddress: ctx.GlobalString(RPCListenAddrFlag.Name),
+		ListenPort:    uint(ctx.GlobalInt(RPCPortFlag.Name)),
+		CorsDomain:    ctx.GlobalString(RPCCORSDomainFlag.Name),
+	}
+
+	xeth := xeth.New(eth, nil)
+	codec := codec.JSON
+
+	apis, err := api.ParseApiString(ctx.GlobalString(RpcApiFlag.Name), codec, xeth, eth)
+	if err != nil {
+		return err
+	}
+
+	return comms.StartHttp(config, codec, api.Merge(apis...))
+}
+
+func StartPProf(ctx *cli.Context) {
+	address := fmt.Sprintf("localhost:%d", ctx.GlobalInt(PProfPortFlag.Name))
+	go func() {
+		log.Println(http.ListenAndServe(address, nil))
+	}()
+}
+
+func ParamToAddress(addr string, am *accounts.Manager) (addrHex string, err error) {
+	if !((len(addr) == 40) || (len(addr) == 42)) { // with or without 0x
+		index, err := strconv.Atoi(addr)
+		if err != nil {
+			Fatalf("Invalid account address '%s'", addr)
+		}
+
+		addrHex, err = am.AddressByIndex(index)
+		if err != nil {
+			return "", err
+		}
+	} else {
+		addrHex = addr
+	}
+	return
+}

cmd/utils/legalese.go

@@ -0,0 +1,41 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package utils
+
+const (
+	legalese = `
+=======================================
+Disclaimer of Liabilites and Warranties
+=======================================
+
+THE USER EXPRESSLY KNOWS AND AGREES THAT THE USER IS USING THE ETHEREUM PLATFORM AT THE USER’S SOLE
+RISK. THE USER REPRESENTS THAT THE USER HAS AN ADEQUATE UNDERSTANDING OF THE RISKS, USAGE AND
+INTRICACIES OF CRYPTOGRAPHIC TOKENS AND BLOCKCHAIN-BASED OPEN SOURCE SOFTWARE, ETH PLATFORM AND ETH.
+THE USER ACKNOWLEDGES AND AGREES THAT, TO THE FULLEST EXTENT PERMITTED BY ANY APPLICABLE LAW, THE
+DISCLAIMERS OF LIABILITY CONTAINED HEREIN APPLY TO ANY AND ALL DAMAGES OR INJURY WHATSOEVER CAUSED
+BY OR RELATED TO RISKS OF, USE OF, OR INABILITY TO USE, ETH OR THE ETHEREUM PLATFORM UNDER ANY CAUSE
+OR ACTION WHATSOEVER OF ANY KIND IN ANY JURISDICTION, INCLUDING, WITHOUT LIMITATION, ACTIONS FOR
+BREACH OF WARRANTY, BREACH OF CONTRACT OR TORT (INCLUDING NEGLIGENCE) AND THAT NEITHER STIFTUNG
+ETHEREUM NOR ETHEREUM TEAM SHALL BE LIABLE FOR ANY INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY OR
+CONSEQUENTIAL DAMAGES, INCLUDING FOR LOSS OF PROFITS, GOODWILL OR DATA. SOME JURISDICTIONS DO NOT
+ALLOW THE EXCLUSION OF CERTAIN WARRANTIES OR THE LIMITATION OR EXCLUSION OF LIABILITY FOR CERTAIN
+TYPES OF DAMAGES. THEREFORE, SOME OF THE ABOVE LIMITATIONS IN THIS SECTION MAY NOT APPLY TO A USER.
+IN PARTICULAR, NOTHING IN THESE TERMS SHALL AFFECT THE STATUTORY RIGHTS OF ANY USER OR EXCLUDE
+INJURY ARISING FROM ANY WILLFUL MISCONDUCT OR FRAUD OF STIFTUNG ETHEREUM.
+
+Do you accept this agreement?`
+)