Merge branch 'release/0.9.0'

3 files changed, 73 insertions, 327 deletions

diff --git a/cmd/utils/cmd.go b/cmd/utils/cmd.go
index db7bcd35e..d252f3ab2 100644
--- a/cmd/utils/cmd.go
+++ b/cmd/utils/cmd.go
@@ -1,26 +1,46 @@
+/*
+	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/>.
+*/
+/**
+ * @authors
+ * 	Jeffrey Wilcke <i@jev.io>
+ * 	Viktor Tron <viktor@ethdev.com>
+ */
 package utils
 
 import (
 	"fmt"
-	"io"
-	"log"
 	"os"
 	"os/signal"
 	"path"
 	"path/filepath"
 	"regexp"
 	"runtime"
-	"time"
 
 	"bitbucket.org/kardianos/osext"
-	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/eth"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/miner"
-	"github.com/ethereum/go-ethereum/rpc"
-	"github.com/ethereum/go-ethereum/wire"
+	"github.com/ethereum/go-ethereum/rlp"
+	rpchttp "github.com/ethereum/go-ethereum/rpc/http"
+	rpcws "github.com/ethereum/go-ethereum/rpc/ws"
+	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/xeth"
 )
 
@@ -50,15 +70,8 @@ func RunInterruptCallbacks(sig os.Signal) {
 	}
 }
 
-func AbsolutePath(Datadir string, filename string) string {
-	if path.IsAbs(filename) {
-		return filename
-	}
-	return path.Join(Datadir, filename)
-}
-
 func openLogFile(Datadir string, filename string) *os.File {
-	path := AbsolutePath(Datadir, filename)
+	path := ethutil.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))
@@ -74,23 +87,13 @@ func confirm(message string) bool {
 		if r == "n" || r == "y" {
 			break
 		} else {
-			fmt.Printf("Yes or no?", r)
+			fmt.Printf("Yes or no? (%s)", r)
 		}
 	}
 	return r == "y"
 }
 
-func DBSanityCheck(db ethutil.Database) error {
-	d, _ := db.Get([]byte("ProtocolVersion"))
-	protov := ethutil.NewValue(d).Uint()
-	if protov != eth.ProtocolVersion && protov != 0 {
-		return fmt.Errorf("Database version mismatch. Protocol(%d / %d). `rm -rf %s`", protov, eth.ProtocolVersion, ethutil.Config.ExecPath+"/database")
-	}
-
-	return nil
-}
-
-func InitDataDir(Datadir string) {
+func initDataDir(Datadir string) {
 	_, err := os.Stat(Datadir)
 	if err != nil {
 		if os.IsNotExist(err) {
@@ -100,26 +103,8 @@ func InitDataDir(Datadir string) {
 	}
 }
 
-func InitLogging(Datadir string, LogFile string, LogLevel int, DebugFile string) logger.LogSystem {
-	var writer io.Writer
-	if LogFile == "" {
-		writer = os.Stdout
-	} else {
-		writer = openLogFile(Datadir, LogFile)
-	}
-
-	sys := logger.NewStdLogSystem(writer, log.LstdFlags, logger.LogLevel(LogLevel))
-	logger.AddLogSystem(sys)
-	if DebugFile != "" {
-		writer = openLogFile(Datadir, DebugFile)
-		logger.AddLogSystem(logger.NewStdLogSystem(writer, log.LstdFlags, logger.DebugLevel))
-	}
-
-	return sys
-}
-
 func InitConfig(vmType int, ConfigFile string, Datadir string, EnvPrefix string) *ethutil.ConfigManager {
-	InitDataDir(Datadir)
+	initDataDir(Datadir)
 	cfg := ethutil.ReadConfig(ConfigFile, Datadir, EnvPrefix)
 	cfg.VmType = vmType
 
@@ -136,55 +121,17 @@ func exit(err error) {
 	os.Exit(status)
 }
 
-func NewDatabase() ethutil.Database {
-	db, err := ethdb.NewLDBDatabase("database")
-	if err != nil {
+func StartEthereum(ethereum *eth.Ethereum) {
+	clilogger.Infoln("Starting ", ethereum.Name())
+	if err := ethereum.Start(); err != nil {
 		exit(err)
 	}
-	return db
-}
-
-func NewClientIdentity(clientIdentifier, version, customIdentifier string) *wire.SimpleClientIdentity {
-	return wire.NewSimpleClientIdentity(clientIdentifier, version, customIdentifier)
-}
-
-func NewEthereum(db ethutil.Database, clientIdentity wire.ClientIdentity, keyManager *crypto.KeyManager, usePnp bool, OutboundPort string, MaxPeer int) *eth.Ethereum {
-	ethereum, err := eth.New(db, clientIdentity, keyManager, eth.CapDefault, usePnp)
-	if err != nil {
-		clilogger.Fatalln("eth start err:", err)
-	}
-	ethereum.Port = OutboundPort
-	ethereum.MaxPeers = MaxPeer
-	return ethereum
-}
-
-func StartEthereum(ethereum *eth.Ethereum, UseSeed bool) {
-	clilogger.Infof("Starting %s", ethereum.ClientIdentity())
-	ethereum.Start(UseSeed)
 	RegisterInterrupt(func(sig os.Signal) {
 		ethereum.Stop()
 		logger.Flush()
 	})
 }
 
-func ShowGenesis(ethereum *eth.Ethereum) {
-	clilogger.Infoln(ethereum.ChainManager().Genesis())
-	exit(nil)
-}
-
-func NewKeyManager(KeyStore string, Datadir string, db ethutil.Database) *crypto.KeyManager {
-	var keyManager *crypto.KeyManager
-	switch {
-	case KeyStore == "db":
-		keyManager = crypto.NewDBKeyManager(db)
-	case KeyStore == "file":
-		keyManager = crypto.NewFileKeyManager(Datadir)
-	default:
-		exit(fmt.Errorf("unknown keystore type: %s", KeyStore))
-	}
-	return keyManager
-}
-
 func DefaultAssetPath() string {
 	var assetPath string
 	// If the current working directory is the go-ethereum dir
@@ -244,7 +191,7 @@ func KeyTasks(keyManager *crypto.KeyManager, KeyRing string, GenAddr bool, Secre
 
 func StartRpc(ethereum *eth.Ethereum, RpcPort int) {
 	var err error
-	ethereum.RpcServer, err = rpc.NewJsonRpcServer(xeth.NewJSXEth(ethereum), RpcPort)
+	ethereum.RpcServer, err = rpchttp.NewRpcHttpServer(xeth.New(ethereum), RpcPort)
 	if err != nil {
 		clilogger.Errorf("Could not start RPC interface (port %v): %v", RpcPort, err)
 	} else {
@@ -252,6 +199,18 @@ func StartRpc(ethereum *eth.Ethereum, RpcPort int) {
 	}
 }
 
+func StartWebSockets(eth *eth.Ethereum, wsPort int) {
+	clilogger.Infoln("Starting WebSockets")
+
+	var err error
+	eth.WsServer, err = rpcws.NewWebSocketServer(xeth.New(eth), wsPort)
+	if err != nil {
+		clilogger.Errorf("Could not start RPC interface (port %v): %v", wsPort, err)
+	} else {
+		go eth.WsServer.Start()
+	}
+}
+
 var gminer *miner.Miner
 
 func GetMiner() *miner.Miner {
@@ -266,12 +225,7 @@ func StartMining(ethereum *eth.Ethereum) bool {
 		go func() {
 			clilogger.Infoln("Start mining")
 			if gminer == nil {
-				gminer = miner.New(addr, ethereum)
-			}
-			// Give it some time to connect with peers
-			time.Sleep(3 * time.Second)
-			for !ethereum.IsUpToDate() {
-				time.Sleep(5 * time.Second)
+				gminer = miner.New(addr, ethereum, 4)
 			}
 			gminer.Start()
 		}()
@@ -315,9 +269,10 @@ func BlockDo(ethereum *eth.Ethereum, hash []byte) error {
 		return fmt.Errorf("unknown block %x", hash)
 	}
 
-	parent := ethereum.ChainManager().GetBlock(block.PrevHash)
+	parent := ethereum.ChainManager().GetBlock(block.ParentHash())
 
-	_, err := ethereum.BlockManager().TransitionState(parent.State(), parent, block)
+	statedb := state.New(parent.Root(), ethereum.Db())
+	_, err := ethereum.BlockProcessor().TransitionState(statedb, parent, block)
 	if err != nil {
 		return err
 	}
@@ -325,3 +280,25 @@ func BlockDo(ethereum *eth.Ethereum, hash []byte) error {
 	return nil
 
 }
+
+func ImportChain(ethereum *eth.Ethereum, fn string) error {
+	clilogger.Infof("importing chain '%s'\n", fn)
+	fh, err := os.OpenFile(fn, os.O_RDONLY, os.ModePerm)
+	if err != nil {
+		return err
+	}
+	defer fh.Close()
+
+	var chain types.Blocks
+	if err := rlp.Decode(fh, &chain); err != nil {
+		return err
+	}
+
+	ethereum.ChainManager().Reset()
+	if err := ethereum.ChainManager().InsertChain(chain); err != nil {
+		return err
+	}
+	clilogger.Infof("imported %d blocks\n", len(chain))
+
+	return nil
+}
diff --git a/cmd/utils/vm_env.go b/cmd/utils/vm_env.go
deleted file mode 100644
index 461a797c2..000000000
--- a/cmd/utils/vm_env.go
+++ /dev/null
@@ -1,70 +0,0 @@
-package utils
-
-import (
-	"math/big"
-
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/state"
-	"github.com/ethereum/go-ethereum/vm"
-)
-
-type VMEnv struct {
-	state *state.StateDB
-	block *types.Block
-
-	transactor []byte
-	value      *big.Int
-
-	depth int
-	Gas   *big.Int
-}
-
-func NewEnv(state *state.StateDB, block *types.Block, transactor []byte, value *big.Int) *VMEnv {
-	return &VMEnv{
-		state:      state,
-		block:      block,
-		transactor: transactor,
-		value:      value,
-	}
-}
-
-func (self *VMEnv) Origin() []byte        { return self.transactor }
-func (self *VMEnv) BlockNumber() *big.Int { return self.block.Number }
-func (self *VMEnv) PrevHash() []byte      { return self.block.PrevHash }
-func (self *VMEnv) Coinbase() []byte      { return self.block.Coinbase }
-func (self *VMEnv) Time() int64           { return self.block.Time }
-func (self *VMEnv) Difficulty() *big.Int  { return self.block.Difficulty }
-func (self *VMEnv) BlockHash() []byte     { return self.block.Hash() }
-func (self *VMEnv) Value() *big.Int       { return self.value }
-func (self *VMEnv) State() *state.StateDB { return self.state }
-func (self *VMEnv) GasLimit() *big.Int    { return self.block.GasLimit }
-func (self *VMEnv) Depth() int            { return self.depth }
-func (self *VMEnv) SetDepth(i int)        { self.depth = i }
-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, data []byte, gas, price, value *big.Int) *core.Execution {
-	return core.NewExecution(self, addr, data, gas, price, value)
-}
-
-func (self *VMEnv) Call(caller vm.ClosureRef, addr, 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.ClosureRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error) {
-	exe := self.vm(caller.Address(), data, gas, price, value)
-	return exe.Call(addr, caller)
-}
-
-func (self *VMEnv) Create(caller vm.ClosureRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error, vm.ClosureRef) {
-	exe := self.vm(addr, data, gas, price, value)
-	return exe.Create(caller)
-}
diff --git a/cmd/utils/websockets.go b/cmd/utils/websockets.go
deleted file mode 100644
index d3ba50e78..000000000
--- a/cmd/utils/websockets.go
+++ /dev/null
@@ -1,161 +0,0 @@
-package utils
-
-import (
-	"github.com/ethereum/go-ethereum"
-	"github.com/ethereum/go-ethereum/ethutil"
-	"github.com/ethereum/go-ethereum/websocket"
-	"github.com/ethereum/go-ethereum/xeth"
-)
-
-func args(v ...interface{}) []interface{} {
-	return v
-}
-
-type WebSocketServer struct {
-	ethereum        *eth.Ethereum
-	filterCallbacks map[int][]int
-}
-
-func NewWebSocketServer(eth *eth.Ethereum) *WebSocketServer {
-	return &WebSocketServer{eth, make(map[int][]int)}
-}
-
-func (self *WebSocketServer) Serv() {
-	pipe := xeth.NewJSXEth(self.ethereum)
-
-	wsServ := websocket.NewServer("/eth", ":40404")
-	wsServ.MessageFunc(func(c *websocket.Client, msg *websocket.Message) {
-		switch msg.Call {
-		case "compile":
-			data := ethutil.NewValue(msg.Args)
-			bcode, err := ethutil.Compile(data.Get(0).Str(), false)
-			if err != nil {
-				c.Write(args(nil, err.Error()), msg.Seed)
-			}
-
-			code := ethutil.Bytes2Hex(bcode)
-			c.Write(args(code, nil), msg.Seed)
-		case "getBlockByNumber":
-			args := msg.Arguments()
-
-			block := pipe.BlockByNumber(int32(args.Get(0).Uint()))
-			c.Write(block, msg.Seed)
-
-		case "getKey":
-			c.Write(pipe.Key().PrivateKey, msg.Seed)
-		case "transact":
-			if mp, ok := msg.Args[0].(map[string]interface{}); ok {
-				object := mapToTxParams(mp)
-				c.Write(
-					args(pipe.Transact(object["from"], object["to"], object["value"], object["gas"], object["gasPrice"], object["data"])),
-					msg.Seed,
-				)
-
-			}
-		case "getCoinBase":
-			c.Write(pipe.CoinBase(), msg.Seed)
-
-		case "getIsListening":
-			c.Write(pipe.IsListening(), msg.Seed)
-
-		case "getIsMining":
-			c.Write(pipe.IsMining(), msg.Seed)
-
-		case "getPeerCoint":
-			c.Write(pipe.PeerCount(), msg.Seed)
-
-		case "getCountAt":
-			args := msg.Arguments()
-
-			c.Write(pipe.TxCountAt(args.Get(0).Str()), msg.Seed)
-
-		case "getCodeAt":
-			args := msg.Arguments()
-
-			c.Write(len(pipe.CodeAt(args.Get(0).Str())), msg.Seed)
-
-		case "getBlockByHash":
-			args := msg.Arguments()
-
-			c.Write(pipe.BlockByHash(args.Get(0).Str()), msg.Seed)
-
-		case "getStorageAt":
-			args := msg.Arguments()
-
-			c.Write(pipe.StorageAt(args.Get(0).Str(), args.Get(1).Str()), msg.Seed)
-
-		case "getBalanceAt":
-			args := msg.Arguments()
-
-			c.Write(pipe.BalanceAt(args.Get(0).Str()), msg.Seed)
-
-		case "getSecretToAddress":
-			args := msg.Arguments()
-
-			c.Write(pipe.SecretToAddress(args.Get(0).Str()), msg.Seed)
-
-		case "newFilter":
-		case "newFilterString":
-		case "messages":
-			// TODO
-		}
-
-	})
-
-	wsServ.Listen()
-}
-
-func StartWebSockets(eth *eth.Ethereum) {
-	sock := NewWebSocketServer(eth)
-	go sock.Serv()
-}
-
-// TODO This is starting to become a generic method. Move to utils
-func mapToTxParams(object map[string]interface{}) map[string]string {
-	// Default values
-	if object["from"] == nil {
-		object["from"] = ""
-	}
-	if object["to"] == nil {
-		object["to"] = ""
-	}
-	if object["value"] == nil {
-		object["value"] = ""
-	}
-	if object["gas"] == nil {
-		object["gas"] = ""
-	}
-	if object["gasPrice"] == nil {
-		object["gasPrice"] = ""
-	}
-
-	var dataStr string
-	var data []string
-	if str, ok := object["data"].(string); ok {
-		data = []string{str}
-	}
-
-	for _, str := range data {
-		if ethutil.IsHex(str) {
-			str = str[2:]
-
-			if len(str) != 64 {
-				str = ethutil.LeftPadString(str, 64)
-			}
-		} else {
-			str = ethutil.Bytes2Hex(ethutil.LeftPadBytes(ethutil.Big(str).Bytes(), 32))
-		}
-
-		dataStr += str
-	}
-	object["data"] = dataStr
-
-	conv := make(map[string]string)
-	for key, value := range object {
-		if v, ok := value.(string); ok {
-			conv[key] = v
-		}
-	}
-
-	return conv
-}