2015-01-06 03:13:57 -08:00
|
|
|
/*
|
|
|
|
This file is part of go-ethereum
|
2014-10-23 06:48:53 -07:00
|
|
|
|
2015-01-06 03:13:57 -08:00
|
|
|
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>
|
|
|
|
*/
|
2014-06-23 04:20:59 -07:00
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
2015-03-07 03:39:52 -08:00
|
|
|
"bufio"
|
2014-08-06 00:53:12 -07:00
|
|
|
"fmt"
|
|
|
|
"os"
|
2014-07-29 16:05:40 -07:00
|
|
|
"runtime"
|
2015-03-05 18:00:41 -08:00
|
|
|
"strconv"
|
2015-03-10 17:08:42 -07:00
|
|
|
"strings"
|
2014-12-23 09:35:36 -08:00
|
|
|
"time"
|
2014-07-29 16:05:40 -07:00
|
|
|
|
2015-03-05 18:00:41 -08:00
|
|
|
"github.com/codegangsta/cli"
|
2015-03-17 06:12:34 -07:00
|
|
|
"github.com/ethereum/ethash"
|
2014-10-31 06:20:11 -07:00
|
|
|
"github.com/ethereum/go-ethereum/cmd/utils"
|
2015-03-16 08:49:39 -07:00
|
|
|
"github.com/ethereum/go-ethereum/common"
|
2014-12-04 01:53:49 -08:00
|
|
|
"github.com/ethereum/go-ethereum/core/types"
|
2015-01-04 05:20:16 -08:00
|
|
|
"github.com/ethereum/go-ethereum/eth"
|
2014-10-31 04:56:05 -07:00
|
|
|
"github.com/ethereum/go-ethereum/logger"
|
2015-01-07 04:17:48 -08:00
|
|
|
"github.com/ethereum/go-ethereum/state"
|
2015-03-07 03:39:52 -08:00
|
|
|
"github.com/peterh/liner"
|
2014-06-23 04:20:59 -07:00
|
|
|
)
|
|
|
|
|
2014-07-03 09:36:24 -07:00
|
|
|
const (
|
|
|
|
ClientIdentifier = "Ethereum(G)"
|
2015-03-19 07:36:38 -07:00
|
|
|
Version = "0.9.1"
|
2014-07-03 09:36:24 -07:00
|
|
|
)
|
|
|
|
|
2015-03-05 18:00:41 -08:00
|
|
|
var (
|
|
|
|
clilogger = logger.NewLogger("CLI")
|
2015-03-09 14:51:50 -07:00
|
|
|
app = utils.NewApp(Version, "the go-ethereum command line interface")
|
2015-03-05 18:00:41 -08:00
|
|
|
)
|
2014-06-23 04:20:59 -07:00
|
|
|
|
2015-03-05 18:00:41 -08:00
|
|
|
func init() {
|
|
|
|
app.Action = run
|
|
|
|
app.HideVersion = true // we have a command to print the version
|
|
|
|
app.Commands = []cli.Command{
|
2015-03-13 10:37:13 -07:00
|
|
|
blocktestCmd,
|
2015-03-17 06:12:34 -07:00
|
|
|
{
|
|
|
|
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.
|
|
|
|
`,
|
|
|
|
},
|
2015-03-05 18:00:41 -08:00
|
|
|
{
|
|
|
|
Action: version,
|
|
|
|
Name: "version",
|
|
|
|
Usage: "print ethereum version numbers",
|
|
|
|
Description: `
|
|
|
|
The output of this command is supposed to be machine-readable.
|
|
|
|
`,
|
|
|
|
},
|
2015-03-07 03:39:52 -08:00
|
|
|
{
|
|
|
|
Action: accountList,
|
|
|
|
Name: "account",
|
|
|
|
Usage: "manage accounts",
|
|
|
|
Subcommands: []cli.Command{
|
|
|
|
{
|
|
|
|
Action: accountList,
|
|
|
|
Name: "list",
|
|
|
|
Usage: "print account addresses",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
Action: accountCreate,
|
|
|
|
Name: "new",
|
|
|
|
Usage: "create a new account",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2015-03-05 18:00:41 -08:00
|
|
|
{
|
|
|
|
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.
|
|
|
|
`,
|
|
|
|
},
|
|
|
|
{
|
2015-03-14 23:31:40 -07:00
|
|
|
Action: console,
|
|
|
|
Name: "console",
|
2015-03-16 08:49:39 -07:00
|
|
|
Usage: `Ethereum Console: interactive JavaScript environment`,
|
2015-03-14 23:31:40 -07:00
|
|
|
Description: `
|
2015-03-16 08:49:39 -07:00
|
|
|
Console is an interactive shell for the Ethereum JavaScript runtime environment which exposes a node admin interface as well as the DAPP JavaScript API.
|
2015-03-14 23:31:40 -07:00
|
|
|
See https://github.com/ethereum/go-ethereum/wiki/Frontier-Console
|
|
|
|
`,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
Action: execJSFiles,
|
2015-03-05 18:00:41 -08:00
|
|
|
Name: "js",
|
2015-03-14 23:31:40 -07:00
|
|
|
Usage: `executes the given JavaScript files in the Ethereum Frontier JavaScript VM`,
|
2015-03-05 18:00:41 -08:00
|
|
|
Description: `
|
2015-03-16 08:49:39 -07:00
|
|
|
The Ethereum JavaScript VM exposes a node admin interface as well as the DAPP JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Frontier-Console
|
2015-03-05 18:00:41 -08:00
|
|
|
`,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
Action: importchain,
|
|
|
|
Name: "import",
|
|
|
|
Usage: `import a blockchain file`,
|
|
|
|
},
|
2015-03-08 08:44:48 -07:00
|
|
|
{
|
|
|
|
Action: exportchain,
|
|
|
|
Name: "export",
|
|
|
|
Usage: `export blockchain into file`,
|
|
|
|
},
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
|
|
|
app.Flags = []cli.Flag{
|
2015-03-10 17:08:42 -07:00
|
|
|
utils.UnlockedAccountFlag,
|
2015-03-05 18:00:41 -08:00
|
|
|
utils.BootnodesFlag,
|
|
|
|
utils.DataDirFlag,
|
2015-03-14 23:31:40 -07:00
|
|
|
utils.JSpathFlag,
|
2015-03-05 18:00:41 -08:00
|
|
|
utils.ListenPortFlag,
|
|
|
|
utils.LogFileFlag,
|
|
|
|
utils.LogFormatFlag,
|
|
|
|
utils.LogLevelFlag,
|
|
|
|
utils.MaxPeersFlag,
|
|
|
|
utils.MinerThreadsFlag,
|
|
|
|
utils.MiningEnabledFlag,
|
|
|
|
utils.NATFlag,
|
|
|
|
utils.NodeKeyFileFlag,
|
|
|
|
utils.NodeKeyHexFlag,
|
|
|
|
utils.RPCEnabledFlag,
|
|
|
|
utils.RPCListenAddrFlag,
|
|
|
|
utils.RPCPortFlag,
|
2015-03-11 05:56:02 -07:00
|
|
|
utils.UnencryptedKeysFlag,
|
2015-03-06 07:58:52 -08:00
|
|
|
utils.VMDebugFlag,
|
2015-03-18 00:44:58 -07:00
|
|
|
utils.ProtocolVersionFlag,
|
|
|
|
utils.NetworkIdFlag,
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
// missing:
|
|
|
|
// flag.StringVar(&ConfigFile, "conf", defaultConfigFile, "config file")
|
|
|
|
// flag.BoolVar(&DiffTool, "difftool", false, "creates output for diff'ing. Sets LogLevel=0")
|
|
|
|
// flag.StringVar(&DiffType, "diff", "all", "sets the level of diff output [vm, all]. Has no effect if difftool=false")
|
2014-06-23 04:20:59 -07:00
|
|
|
|
2015-03-05 18:00:41 -08:00
|
|
|
// potential subcommands:
|
|
|
|
// flag.StringVar(&SecretFile, "import", "", "imports the file given (hex or mnemonic formats)")
|
|
|
|
// flag.StringVar(&ExportDir, "export", "", "exports the session keyring to files in the directory given")
|
|
|
|
// flag.BoolVar(&GenAddr, "genaddr", false, "create a new priv/pub key")
|
|
|
|
}
|
2014-12-23 05:33:15 -08:00
|
|
|
|
2015-03-05 18:00:41 -08:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
}
|
2014-06-26 02:47:45 -07:00
|
|
|
|
2015-03-05 18:00:41 -08:00
|
|
|
func run(ctx *cli.Context) {
|
|
|
|
fmt.Printf("Welcome to the FRONTIER\n")
|
2015-03-06 03:18:44 -08:00
|
|
|
utils.HandleInterrupt()
|
2015-03-13 10:30:45 -07:00
|
|
|
cfg := utils.MakeEthConfig(ClientIdentifier, Version, ctx)
|
|
|
|
ethereum, err := eth.New(cfg)
|
2015-03-11 15:41:51 -07:00
|
|
|
if err != nil {
|
2015-03-10 07:44:05 -07:00
|
|
|
utils.Fatalf("%v", err)
|
|
|
|
}
|
|
|
|
|
2015-03-13 10:30:45 -07:00
|
|
|
startEth(ctx, ethereum)
|
2015-03-05 18:00:41 -08:00
|
|
|
// this blocks the thread
|
2015-03-13 10:30:45 -07:00
|
|
|
ethereum.WaitForShutdown()
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2014-07-11 07:04:27 -07:00
|
|
|
|
2015-03-14 23:31:40 -07:00
|
|
|
func console(ctx *cli.Context) {
|
2015-03-13 10:30:45 -07:00
|
|
|
cfg := utils.MakeEthConfig(ClientIdentifier, Version, ctx)
|
|
|
|
ethereum, err := eth.New(cfg)
|
2015-03-11 15:41:51 -07:00
|
|
|
if err != nil {
|
2015-03-10 07:44:05 -07:00
|
|
|
utils.Fatalf("%v", err)
|
|
|
|
}
|
|
|
|
|
2015-03-13 10:30:45 -07:00
|
|
|
startEth(ctx, ethereum)
|
2015-03-14 23:31:40 -07:00
|
|
|
repl := newJSRE(ethereum, ctx.String(utils.JSpathFlag.Name))
|
|
|
|
repl.interactive()
|
|
|
|
|
|
|
|
ethereum.Stop()
|
|
|
|
ethereum.WaitForShutdown()
|
|
|
|
}
|
|
|
|
|
|
|
|
func execJSFiles(ctx *cli.Context) {
|
|
|
|
cfg := utils.MakeEthConfig(ClientIdentifier, Version, ctx)
|
|
|
|
ethereum, err := eth.New(cfg)
|
|
|
|
if err != nil {
|
|
|
|
utils.Fatalf("%v", err)
|
2015-01-06 16:21:55 -08:00
|
|
|
}
|
2015-03-14 23:31:40 -07:00
|
|
|
|
|
|
|
startEth(ctx, ethereum)
|
|
|
|
repl := newJSRE(ethereum, ctx.String(utils.JSpathFlag.Name))
|
|
|
|
for _, file := range ctx.Args() {
|
|
|
|
repl.exec(file)
|
|
|
|
}
|
|
|
|
|
2015-03-13 10:30:45 -07:00
|
|
|
ethereum.Stop()
|
|
|
|
ethereum.WaitForShutdown()
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2015-01-06 16:21:55 -08:00
|
|
|
|
2015-03-05 18:00:41 -08:00
|
|
|
func startEth(ctx *cli.Context, eth *eth.Ethereum) {
|
|
|
|
utils.StartEthereum(eth)
|
2015-03-10 17:08:42 -07:00
|
|
|
|
|
|
|
// Load startup keys. XXX we are going to need a different format
|
|
|
|
account := ctx.GlobalString(utils.UnlockedAccountFlag.Name)
|
|
|
|
if len(account) > 0 {
|
|
|
|
split := strings.Split(account, ":")
|
|
|
|
if len(split) != 2 {
|
|
|
|
utils.Fatalf("Illegal 'unlock' format (address:password)")
|
|
|
|
}
|
2015-03-11 08:33:04 -07:00
|
|
|
am := eth.AccountManager()
|
2015-03-10 17:08:42 -07:00
|
|
|
// Attempt to unlock the account
|
2015-03-16 03:27:38 -07:00
|
|
|
err := am.Unlock(common.FromHex(split[0]), split[1])
|
2015-03-10 17:08:42 -07:00
|
|
|
if err != nil {
|
|
|
|
utils.Fatalf("Unlock account failed '%v'", err)
|
|
|
|
}
|
|
|
|
}
|
2015-03-10 08:44:22 -07:00
|
|
|
// Start auxiliary services if enabled.
|
2015-03-05 18:00:41 -08:00
|
|
|
if ctx.GlobalBool(utils.RPCEnabledFlag.Name) {
|
2015-03-09 15:00:27 -07:00
|
|
|
utils.StartRPC(eth, ctx)
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
|
|
|
if ctx.GlobalBool(utils.MiningEnabledFlag.Name) {
|
2015-03-11 15:35:34 -07:00
|
|
|
eth.StartMining()
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
|
|
|
}
|
2015-01-05 08:10:42 -08:00
|
|
|
|
2015-03-07 03:39:52 -08:00
|
|
|
func accountList(ctx *cli.Context) {
|
|
|
|
am := utils.GetAccountManager(ctx)
|
|
|
|
accts, err := am.Accounts()
|
|
|
|
if err != nil {
|
|
|
|
utils.Fatalf("Could not list accounts: %v", err)
|
|
|
|
}
|
|
|
|
for _, acct := range accts {
|
|
|
|
fmt.Printf("Address: %#x\n", acct)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func accountCreate(ctx *cli.Context) {
|
|
|
|
am := utils.GetAccountManager(ctx)
|
2015-03-11 05:56:02 -07:00
|
|
|
passphrase := ""
|
|
|
|
if !ctx.GlobalBool(utils.UnencryptedKeysFlag.Name) {
|
|
|
|
fmt.Println("The new account will be encrypted with a passphrase.")
|
|
|
|
fmt.Println("Please enter a passphrase now.")
|
|
|
|
auth, err := readPassword("Passphrase: ", true)
|
|
|
|
if err != nil {
|
|
|
|
utils.Fatalf("%v", err)
|
|
|
|
}
|
|
|
|
confirm, err := readPassword("Repeat Passphrase: ", false)
|
|
|
|
if err != nil {
|
|
|
|
utils.Fatalf("%v", err)
|
|
|
|
}
|
|
|
|
if auth != confirm {
|
|
|
|
utils.Fatalf("Passphrases did not match.")
|
|
|
|
}
|
|
|
|
passphrase = auth
|
2015-03-07 03:39:52 -08:00
|
|
|
}
|
2015-03-11 05:56:02 -07:00
|
|
|
acct, err := am.NewAccount(passphrase)
|
2015-03-07 03:39:52 -08:00
|
|
|
if err != nil {
|
|
|
|
utils.Fatalf("Could not create the account: %v", err)
|
|
|
|
}
|
2015-03-20 04:17:57 -07:00
|
|
|
fmt.Printf("Address: %x\n", acct.Address)
|
2015-03-07 03:39:52 -08:00
|
|
|
}
|
|
|
|
|
2015-03-05 18:00:41 -08:00
|
|
|
func importchain(ctx *cli.Context) {
|
|
|
|
if len(ctx.Args()) != 1 {
|
|
|
|
utils.Fatalf("This command requires an argument.")
|
|
|
|
}
|
2015-03-08 08:44:48 -07:00
|
|
|
chainmgr, _, _ := utils.GetChain(ctx)
|
2015-03-05 18:00:41 -08:00
|
|
|
start := time.Now()
|
2015-03-08 08:44:48 -07:00
|
|
|
err := utils.ImportChain(chainmgr, ctx.Args().First())
|
2014-08-22 03:14:37 -07:00
|
|
|
if err != nil {
|
2015-03-05 18:00:41 -08:00
|
|
|
utils.Fatalf("Import error: %v\n", err)
|
2014-08-22 03:14:37 -07:00
|
|
|
}
|
2015-03-08 08:44:48 -07:00
|
|
|
fmt.Printf("Import done in %v", time.Since(start))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
func exportchain(ctx *cli.Context) {
|
|
|
|
if len(ctx.Args()) != 1 {
|
|
|
|
utils.Fatalf("This command requires an argument.")
|
|
|
|
}
|
|
|
|
chainmgr, _, _ := utils.GetChain(ctx)
|
|
|
|
start := time.Now()
|
|
|
|
err := utils.ExportChain(chainmgr, ctx.Args().First())
|
|
|
|
if err != nil {
|
|
|
|
utils.Fatalf("Export error: %v\n", err)
|
|
|
|
}
|
|
|
|
fmt.Printf("Export done in %v", time.Since(start))
|
2015-03-05 18:00:41 -08:00
|
|
|
return
|
|
|
|
}
|
2015-01-05 08:10:42 -08:00
|
|
|
|
2015-03-05 18:00:41 -08:00
|
|
|
func dump(ctx *cli.Context) {
|
2015-03-08 08:44:48 -07:00
|
|
|
chainmgr, _, stateDb := utils.GetChain(ctx)
|
2015-03-05 18:00:41 -08:00
|
|
|
for _, arg := range ctx.Args() {
|
2014-11-18 10:52:45 -08:00
|
|
|
var block *types.Block
|
2015-03-05 18:00:41 -08:00
|
|
|
if hashish(arg) {
|
2015-03-16 03:27:38 -07:00
|
|
|
block = chainmgr.GetBlock(common.Hex2Bytes(arg))
|
2014-08-06 00:53:12 -07:00
|
|
|
} else {
|
2015-03-05 18:00:41 -08:00
|
|
|
num, _ := strconv.Atoi(arg)
|
2015-03-08 08:44:48 -07:00
|
|
|
block = chainmgr.GetBlockByNumber(uint64(num))
|
2014-08-06 00:53:12 -07:00
|
|
|
}
|
|
|
|
if block == nil {
|
|
|
|
fmt.Println("{}")
|
2015-03-05 18:00:41 -08:00
|
|
|
utils.Fatalf("block not found")
|
|
|
|
} else {
|
2015-03-06 09:26:16 -08:00
|
|
|
statedb := state.New(block.Root(), stateDb)
|
2015-03-05 18:00:41 -08:00
|
|
|
fmt.Printf("%s\n", statedb.Dump())
|
|
|
|
// fmt.Println(block)
|
2014-12-23 05:33:15 -08:00
|
|
|
}
|
2015-02-28 14:01:41 -08:00
|
|
|
}
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2015-02-28 14:01:41 -08:00
|
|
|
|
2015-03-17 06:12:34 -07:00
|
|
|
func makedag(ctx *cli.Context) {
|
|
|
|
chain, _, _ := utils.GetChain(ctx)
|
|
|
|
pow := ethash.New(chain)
|
|
|
|
fmt.Println("making cache")
|
|
|
|
pow.UpdateCache(true)
|
|
|
|
fmt.Println("making DAG")
|
|
|
|
pow.UpdateDAG()
|
|
|
|
}
|
|
|
|
|
2015-03-05 18:00:41 -08:00
|
|
|
func version(c *cli.Context) {
|
2015-03-08 08:50:27 -07:00
|
|
|
fmt.Printf(`%v
|
|
|
|
Version: %v
|
|
|
|
Protocol Version: %d
|
|
|
|
Network Id: %d
|
|
|
|
GO: %s
|
|
|
|
OS: %s
|
2015-01-06 16:21:55 -08:00
|
|
|
GOPATH=%s
|
|
|
|
GOROOT=%s
|
2015-03-18 00:44:58 -07:00
|
|
|
`, ClientIdentifier, Version, c.GlobalInt(utils.ProtocolVersionFlag.Name), c.GlobalInt(utils.NetworkIdFlag.Name), runtime.Version(), runtime.GOOS, os.Getenv("GOPATH"), runtime.GOROOT())
|
2015-01-06 16:21:55 -08:00
|
|
|
}
|
2015-03-07 03:39:52 -08:00
|
|
|
|
|
|
|
// hashish returns true for strings that look like hashes.
|
|
|
|
func hashish(x string) bool {
|
|
|
|
_, err := strconv.Atoi(x)
|
|
|
|
return err != nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func readPassword(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
|
|
|
|
}
|