Moved utils to cmd

9 files changed, 536 insertions, 6 deletions

diff --git a/cmd/ethereum/cmd.go b/cmd/ethereum/cmd.go
index d8cb19eaf..8710d6136 100644
--- a/cmd/ethereum/cmd.go
+++ b/cmd/ethereum/cmd.go
@@ -23,8 +23,8 @@ import (
 
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/cmd/ethereum/repl"
+	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/javascript"
-	"github.com/ethereum/go-ethereum/utils"
 )
 
 func InitJsConsole(ethereum *eth.Ethereum) {
diff --git a/cmd/ethereum/main.go b/cmd/ethereum/main.go
index fa85865fc..d7bc74c27 100644
--- a/cmd/ethereum/main.go
+++ b/cmd/ethereum/main.go
@@ -23,9 +23,9 @@ import (
 	"runtime"
 
 	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/logger"
-	"github.com/ethereum/go-ethereum/utils"
 	"github.com/ethgo.old/ethlog"
 )
 
diff --git a/cmd/mist/bindings.go b/cmd/mist/bindings.go
index 8b038587b..f5a0dfcff 100644
--- a/cmd/mist/bindings.go
+++ b/cmd/mist/bindings.go
@@ -23,10 +23,10 @@ import (
 	"strconv"
 
 	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/ethpipe"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/logger"
-	"github.com/ethereum/go-ethereum/utils"
 )
 
 type plugin struct {
diff --git a/cmd/mist/debugger.go b/cmd/mist/debugger.go
index d786a0395..fadc241ff 100644
--- a/cmd/mist/debugger.go
+++ b/cmd/mist/debugger.go
@@ -25,9 +25,9 @@ import (
 	"unicode"
 
 	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
-	"github.com/ethereum/go-ethereum/utils"
 	"github.com/ethereum/go-ethereum/vm"
 	"gopkg.in/qml.v1"
 )
diff --git a/cmd/mist/flags.go b/cmd/mist/flags.go
index 7de2a881d..2ae0a0487 100644
--- a/cmd/mist/flags.go
+++ b/cmd/mist/flags.go
@@ -28,6 +28,7 @@ import (
 	"runtime"
 
 	"bitbucket.org/kardianos/osext"
+	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/vm"
 )
 
@@ -116,7 +117,7 @@ func Init() {
 	flag.StringVar(&Datadir, "datadir", defaultDataDir(), "specifies the datadir to use")
 	flag.StringVar(&ConfigFile, "conf", defaultConfigFile, "config file")
 	flag.StringVar(&DebugFile, "debug", "", "debug file (no debugging if not set)")
-	flag.IntVar(&LogLevel, "loglevel", int(repllogger.InfoLevel), "loglevel: 0-5: silent,error,warn,info,debug,debug detail)")
+	flag.IntVar(&LogLevel, "loglevel", int(logger.InfoLevel), "loglevel: 0-5: silent,error,warn,info,debug,debug detail)")
 
 	flag.StringVar(&AssetPath, "asset_path", defaultAssetPath(), "absolute path to GUI assets directory")
 
diff --git a/cmd/mist/main.go b/cmd/mist/main.go
index b7282d9b5..bb981b950 100644
--- a/cmd/mist/main.go
+++ b/cmd/mist/main.go
@@ -22,8 +22,8 @@ import (
 	"runtime"
 
 	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/logger"
-	"github.com/ethereum/go-ethereum/utils"
 	"gopkg.in/qml.v1"
 )
 
diff --git a/cmd/utils/cmd.go b/cmd/utils/cmd.go
new file mode 100644
index 000000000..7ee41d042
--- /dev/null
+++ b/cmd/utils/cmd.go
@@ -0,0 +1,327 @@
+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/crypto"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/ethminer"
+	"github.com/ethereum/go-ethereum/ethpipe"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/ethwire"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+var clilogger = logger.NewLogger("CLI")
+var interruptCallbacks = []func(os.Signal){}
+
+// Register interrupt handlers callbacks
+func RegisterInterrupt(cb func(os.Signal)) {
+	interruptCallbacks = append(interruptCallbacks, cb)
+}
+
+// go routine that call interrupt handlers in order of registering
+func HandleInterrupt() {
+	c := make(chan os.Signal, 1)
+	go func() {
+		signal.Notify(c, os.Interrupt)
+		for sig := range c {
+			clilogger.Errorf("Shutting down (%v) ... \n", sig)
+			RunInterruptCallbacks(sig)
+		}
+	}()
+}
+
+func RunInterruptCallbacks(sig os.Signal) {
+	for _, cb := range interruptCallbacks {
+		cb(sig)
+	}
+}
+
+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)
+	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 confirm(message string) bool {
+	fmt.Println(message, "Are you sure? (y/n)")
+	var r string
+	fmt.Scanln(&r)
+	for ; ; fmt.Scanln(&r) {
+		if r == "n" || r == "y" {
+			break
+		} else {
+			fmt.Printf("Yes or no?", 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) {
+	_, err := os.Stat(Datadir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			fmt.Printf("Data directory '%s' doesn't exist, creating it\n", Datadir)
+			os.Mkdir(Datadir, 0777)
+		}
+	}
+}
+
+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)
+	cfg := ethutil.ReadConfig(ConfigFile, Datadir, EnvPrefix)
+	cfg.VmType = vmType
+
+	return cfg
+}
+
+func exit(err error) {
+	status := 0
+	if err != nil {
+		clilogger.Errorln("Fatal: ", err)
+		status = 1
+	}
+	logger.Flush()
+	os.Exit(status)
+}
+
+func NewDatabase() ethutil.Database {
+	db, err := ethdb.NewLDBDatabase("database")
+	if err != nil {
+		exit(err)
+	}
+	return db
+}
+
+func NewClientIdentity(clientIdentifier, version, customIdentifier string) *ethwire.SimpleClientIdentity {
+	clilogger.Infoln("identity created")
+	return ethwire.NewSimpleClientIdentity(clientIdentifier, version, customIdentifier)
+}
+
+func NewEthereum(db ethutil.Database, clientIdentity ethwire.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
+	// assume a debug build and use the source directory as
+	// asset directory.
+	pwd, _ := os.Getwd()
+	if pwd == path.Join(os.Getenv("GOPATH"), "src", "github.com", "ethereum", "go-ethereum", "cmd", "mist") {
+		assetPath = path.Join(pwd, "assets")
+	} else {
+		switch runtime.GOOS {
+		case "darwin":
+			// Get Binary Directory
+			exedir, _ := osext.ExecutableFolder()
+			assetPath = filepath.Join(exedir, "../Resources")
+		case "linux":
+			assetPath = "/usr/share/mist"
+		case "windows":
+			assetPath = "./assets"
+		default:
+			assetPath = "."
+		}
+	}
+	return assetPath
+}
+
+func KeyTasks(keyManager *crypto.KeyManager, KeyRing string, GenAddr bool, SecretFile string, ExportDir string, NonInteractive bool) {
+
+	var err error
+	switch {
+	case GenAddr:
+		if NonInteractive || confirm("This action overwrites your old private key.") {
+			err = keyManager.Init(KeyRing, 0, true)
+		}
+		exit(err)
+	case len(SecretFile) > 0:
+		SecretFile = ethutil.ExpandHomePath(SecretFile)
+
+		if NonInteractive || confirm("This action overwrites your old private key.") {
+			err = keyManager.InitFromSecretsFile(KeyRing, 0, SecretFile)
+		}
+		exit(err)
+	case len(ExportDir) > 0:
+		err = keyManager.Init(KeyRing, 0, false)
+		if err == nil {
+			err = keyManager.Export(ExportDir)
+		}
+		exit(err)
+	default:
+		// Creates a keypair if none exists
+		err = keyManager.Init(KeyRing, 0, false)
+		if err != nil {
+			exit(err)
+		}
+	}
+}
+
+func StartRpc(ethereum *eth.Ethereum, RpcPort int) {
+	var err error
+	ethereum.RpcServer, err = rpc.NewJsonRpcServer(ethpipe.NewJSPipe(ethereum), RpcPort)
+	if err != nil {
+		clilogger.Errorf("Could not start RPC interface (port %v): %v", RpcPort, err)
+	} else {
+		go ethereum.RpcServer.Start()
+	}
+}
+
+var miner *ethminer.Miner
+
+func GetMiner() *ethminer.Miner {
+	return miner
+}
+
+func StartMining(ethereum *eth.Ethereum) bool {
+	if !ethereum.Mining {
+		ethereum.Mining = true
+		addr := ethereum.KeyManager().Address()
+
+		go func() {
+			clilogger.Infoln("Start mining")
+			if miner == nil {
+				miner = ethminer.NewDefaultMiner(addr, ethereum)
+			}
+			// Give it some time to connect with peers
+			time.Sleep(3 * time.Second)
+			for !ethereum.IsUpToDate() {
+				time.Sleep(5 * time.Second)
+			}
+			miner.Start()
+		}()
+		RegisterInterrupt(func(os.Signal) {
+			StopMining(ethereum)
+		})
+		return true
+	}
+	return false
+}
+
+func FormatTransactionData(data string) []byte {
+	d := ethutil.StringToByteFunc(data, func(s string) (ret []byte) {
+		slice := regexp.MustCompile("\\n|\\s").Split(s, 1000000000)
+		for _, dataItem := range slice {
+			d := ethutil.FormatData(dataItem)
+			ret = append(ret, d...)
+		}
+		return
+	})
+
+	return d
+}
+
+func StopMining(ethereum *eth.Ethereum) bool {
+	if ethereum.Mining && miner != nil {
+		miner.Stop()
+		clilogger.Infoln("Stopped mining")
+		ethereum.Mining = false
+
+		return true
+	}
+
+	return false
+}
+
+// Replay block
+func BlockDo(ethereum *eth.Ethereum, hash []byte) error {
+	block := ethereum.ChainManager().GetBlock(hash)
+	if block == nil {
+		return fmt.Errorf("unknown block %x", hash)
+	}
+
+	parent := ethereum.ChainManager().GetBlock(block.PrevHash)
+
+	_, err := ethereum.StateManager().ApplyDiff(parent.State(), parent, block)
+	if err != nil {
+		return err
+	}
+
+	return nil
+
+}
diff --git a/cmd/utils/vm_env.go b/cmd/utils/vm_env.go
new file mode 100644
index 000000000..0a7b589ee
--- /dev/null
+++ b/cmd/utils/vm_env.go
@@ -0,0 +1,41 @@
+package utils
+
+import (
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/chain"
+	"github.com/ethereum/go-ethereum/ethstate"
+	"github.com/ethereum/go-ethereum/vm"
+)
+
+type VMEnv struct {
+	state *ethstate.State
+	block *chain.Block
+
+	transactor []byte
+	value      *big.Int
+}
+
+func NewEnv(state *ethstate.State, block *chain.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() *ethstate.State { return self.state }
+func (self *VMEnv) GasLimit() *big.Int     { return self.block.GasLimit }
+func (self *VMEnv) AddLog(ethstate.Log)    {}
+func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error {
+	return vm.Transfer(from, to, amount)
+}
diff --git a/cmd/utils/websockets.go b/cmd/utils/websockets.go
new file mode 100644
index 000000000..7bda805ac
--- /dev/null
+++ b/cmd/utils/websockets.go
@@ -0,0 +1,161 @@
+package utils
+
+import (
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/ethpipe"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/websocket"
+)
+
+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 := ethpipe.NewJSPipe(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
+}