package utils import ( "github.com/ethereum/eth-go" "github.com/ethereum/eth-go/ethminer" "github.com/ethereum/eth-go/ethpub" "github.com/ethereum/eth-go/ethrpc" "github.com/ethereum/eth-go/ethutil" "github.com/ethereum/eth-go/ethlog" "log" "io" "path" "os" "os/signal" "fmt" "time" "strings" ) var logger = ethlog.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 { logger.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 InitDataDir(Datadir string) { _, err := os.Stat(Datadir) if err != nil { if os.IsNotExist(err) { fmt.Printf("Debug logging directory '%s' doesn't exist, creating it\n", Datadir) os.Mkdir(Datadir, 0777) } } } func InitLogging (Datadir string, LogFile string, LogLevel int, DebugFile string) { var writer io.Writer if LogFile == "" { writer = os.Stdout } else { writer = openLogFile(Datadir, LogFile) } ethlog.AddLogSystem(ethlog.NewStdLogSystem(writer, log.LstdFlags, ethlog.LogLevel(LogLevel))) if DebugFile != "" { writer = openLogFile(Datadir, DebugFile) ethlog.AddLogSystem(ethlog.NewStdLogSystem(writer, log.LstdFlags, ethlog.DebugLevel)) } } func InitConfig(ConfigFile string, Datadir string, Identifier string, EnvPrefix string) { InitDataDir(Datadir) ethutil.ReadConfig(ConfigFile, Datadir, Identifier, EnvPrefix) ethutil.Config.Set("rpcport", "700") } func exit(status int) { ethlog.Flush() os.Exit(status) } func NewEthereum(UseUPnP bool, OutboundPort string, MaxPeer int) *eth.Ethereum { ethereum, err := eth.New(eth.CapDefault, UseUPnP) if err != nil { logger.Fatalln("eth start err:", err) } ethereum.Port = OutboundPort ethereum.MaxPeers = MaxPeer return ethereum } func StartEthereum(ethereum *eth.Ethereum, UseSeed bool) { logger.Infof("Starting Ethereum v%s", ethutil.Config.Ver) ethereum.Start(UseSeed) RegisterInterrupt(func(sig os.Signal) { ethereum.Stop() ethlog.Flush() }) } func ShowGenesis(ethereum *eth.Ethereum) { logger.Infoln(ethereum.BlockChain().Genesis()) exit(0) } func KeyTasks(GenAddr bool, ImportKey string, ExportKey bool, NonInteractive bool) { switch { case GenAddr: if NonInteractive || confirm("This action overwrites your old private key.") { CreateKeyPair(true) } exit(0) case len(ImportKey) > 0: if NonInteractive || confirm("This action overwrites your old private key.") { // import should be from file mnemonic := strings.Split(ImportKey, " ") if len(mnemonic) == 24 { logger.Infoln("Got mnemonic key, importing.") key := ethutil.MnemonicDecode(mnemonic) ImportPrivateKey(key) } else if len(mnemonic) == 1 { logger.Infoln("Got hex key, importing.") ImportPrivateKey(ImportKey) } else { logger.Errorln("Did not recognise format, exiting.") } } exit(0) case ExportKey: // this should be exporting to a filename keyPair := ethutil.GetKeyRing().Get(0) fmt.Printf(` Generating new address and keypair. Please keep your keys somewhere save. ++++++++++++++++ KeyRing +++++++++++++++++++ addr: %x prvk: %x pubk: %x ++++++++++++++++++++++++++++++++++++++++++++ save these words so you can restore your account later: %s `, keyPair.Address(), keyPair.PrivateKey, keyPair.PublicKey) exit(0) default: // Creates a keypair if none exists CreateKeyPair(false) } } func StartRpc(ethereum *eth.Ethereum, RpcPort int) { var err error ethereum.RpcServer, err = ethrpc.NewJsonRpcServer(ethpub.NewPEthereum(ethereum), RpcPort) if err != nil { logger.Errorf("Could not start RPC interface (port %v): %v", RpcPort, err) } else { go ethereum.RpcServer.Start() } } var miner ethminer.Miner func StartMining(ethereum *eth.Ethereum) bool { if !ethereum.Mining { ethereum.Mining = true if ethutil.GetKeyRing().Len() == 0 { logger.Errorln("No address found, can't start mining") ethereum.Mining = false return true //???? } keyPair := ethutil.GetKeyRing().Get(0) addr := keyPair.Address() go func() { miner = ethminer.NewDefaultMiner(addr, ethereum) // Give it some time to connect with peers time.Sleep(3 * time.Second) logger.Infoln("Miner started") miner := ethminer.NewDefaultMiner(addr, ethereum) miner.Start() }() RegisterInterrupt(func(os.Signal) { StopMining(ethereum) }) return true } return false } func StopMining(ethereum *eth.Ethereum) bool { if ethereum.Mining { miner.Stop() logger.Infoln("Miner stopped") ethereum.Mining = false return true } return false } // Replay block func BlockDo(ethereum *eth.Ethereum, hash []byte) error { block := ethereum.BlockChain().GetBlock(hash) if block == nil { return fmt.Errorf("unknown block %x", hash) } parent := ethereum.BlockChain().GetBlock(block.PrevHash) _, err := ethereum.StateManager().ApplyDiff(parent.State(), parent, block) if err != nil { return err } return nil }