2015-07-06 17:54:22 -07:00
|
|
|
// 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
|
2015-07-22 09:48:40 -07:00
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2015-07-06 17:54:22 -07:00
|
|
|
// GNU General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU General Public License
|
2015-07-22 09:48:40 -07:00
|
|
|
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
2015-07-06 17:54:22 -07:00
|
|
|
|
2015-03-05 18:00:41 -08:00
|
|
|
package utils
|
|
|
|
|
|
|
|
import (
|
|
|
|
"crypto/ecdsa"
|
2015-04-20 08:45:37 -07:00
|
|
|
"fmt"
|
|
|
|
"log"
|
2015-10-07 08:21:13 -07:00
|
|
|
"math"
|
2015-05-09 03:00:51 -07:00
|
|
|
"math/big"
|
2015-08-07 00:56:49 -07:00
|
|
|
"net"
|
2015-04-20 08:45:37 -07:00
|
|
|
"net/http"
|
2015-03-09 15:00:27 -07:00
|
|
|
"os"
|
2015-05-12 05:24:11 -07:00
|
|
|
"path/filepath"
|
2015-05-12 06:20:53 -07:00
|
|
|
"runtime"
|
2015-07-07 01:32:05 -07:00
|
|
|
"strconv"
|
2015-05-12 05:24:11 -07:00
|
|
|
|
2015-03-05 18:00:41 -08:00
|
|
|
"github.com/codegangsta/cli"
|
2015-04-13 01:13:52 -07:00
|
|
|
"github.com/ethereum/ethash"
|
2015-03-07 03:39:52 -08:00
|
|
|
"github.com/ethereum/go-ethereum/accounts"
|
2015-03-18 00:44:58 -07:00
|
|
|
"github.com/ethereum/go-ethereum/common"
|
2015-03-05 18:00:41 -08:00
|
|
|
"github.com/ethereum/go-ethereum/core"
|
2015-08-07 00:56:49 -07:00
|
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
2015-03-05 18:00:41 -08:00
|
|
|
"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"
|
2015-04-03 08:09:01 -07:00
|
|
|
"github.com/ethereum/go-ethereum/logger/glog"
|
2015-08-07 00:56:49 -07:00
|
|
|
"github.com/ethereum/go-ethereum/metrics"
|
2015-03-05 18:00:41 -08:00
|
|
|
"github.com/ethereum/go-ethereum/p2p/nat"
|
2015-10-07 08:21:13 -07:00
|
|
|
"github.com/ethereum/go-ethereum/params"
|
2015-06-08 02:01:02 -07:00
|
|
|
"github.com/ethereum/go-ethereum/rpc/api"
|
|
|
|
"github.com/ethereum/go-ethereum/rpc/codec"
|
2015-06-15 07:48:59 -07:00
|
|
|
"github.com/ethereum/go-ethereum/rpc/comms"
|
2015-08-07 00:56:49 -07:00
|
|
|
"github.com/ethereum/go-ethereum/rpc/shared"
|
|
|
|
"github.com/ethereum/go-ethereum/rpc/useragent"
|
2015-06-15 07:48:59 -07:00
|
|
|
"github.com/ethereum/go-ethereum/xeth"
|
2015-03-05 18:00:41 -08:00
|
|
|
)
|
|
|
|
|
2015-03-10 08:44:48 -07:00
|
|
|
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}}
|
|
|
|
`
|
|
|
|
}
|
|
|
|
|
2015-03-09 14:51:50 -07:00
|
|
|
// NewApp creates an app with sane defaults.
|
|
|
|
func NewApp(version, usage string) *cli.App {
|
|
|
|
app := cli.NewApp()
|
2015-05-12 05:24:11 -07:00
|
|
|
app.Name = filepath.Base(os.Args[0])
|
2015-03-09 14:51:50 -07:00
|
|
|
app.Author = ""
|
2015-03-25 17:03:03 -07:00
|
|
|
//app.Authors = nil
|
2015-03-09 14:51:50 -07:00
|
|
|
app.Email = ""
|
|
|
|
app.Version = version
|
|
|
|
app.Usage = usage
|
|
|
|
return app
|
|
|
|
}
|
|
|
|
|
2015-03-05 18:00:41 -08:00
|
|
|
// 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
|
2015-04-08 06:43:55 -07:00
|
|
|
DataDirFlag = DirectoryFlag{
|
2015-03-05 18:00:41 -08:00
|
|
|
Name: "datadir",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Data directory for the databases and keystore",
|
2015-04-08 06:43:55 -07:00
|
|
|
Value: DirectoryString{common.DefaultDataDir()},
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2015-03-18 00:44:58 -07:00
|
|
|
NetworkIdFlag = cli.IntFlag{
|
|
|
|
Name: "networkid",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Network identifier (integer, 0=Olympic, 1=Frontier, 2=Morden)",
|
2015-03-18 00:44:58 -07:00
|
|
|
Value: eth.NetworkId,
|
|
|
|
}
|
2015-10-29 10:53:24 -07:00
|
|
|
OlympicFlag = cli.BoolFlag{
|
|
|
|
Name: "olympic",
|
|
|
|
Usage: "Olympic network: pre-configured pre-release test network",
|
2015-06-08 03:12:13 -07:00
|
|
|
}
|
2015-10-29 10:53:24 -07:00
|
|
|
TestNetFlag = cli.BoolFlag{
|
|
|
|
Name: "testnet",
|
|
|
|
Usage: "Morden network: pre-configured test network with modified starting nonces (replay protection)",
|
2015-07-10 05:29:40 -07:00
|
|
|
}
|
2015-09-06 06:46:54 -07:00
|
|
|
DevModeFlag = cli.BoolFlag{
|
|
|
|
Name: "dev",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Developer mode: pre-configured private network with several debugging flags",
|
2015-09-06 06:46:54 -07:00
|
|
|
}
|
2015-10-29 10:53:24 -07:00
|
|
|
GenesisFileFlag = cli.StringFlag{
|
|
|
|
Name: "genesis",
|
|
|
|
Usage: "Insert/overwrite the genesis block (JSON format)",
|
2015-10-05 04:01:34 -07:00
|
|
|
}
|
2015-04-18 14:53:30 -07:00
|
|
|
IdentityFlag = cli.StringFlag{
|
|
|
|
Name: "identity",
|
2015-04-21 16:41:34 -07:00
|
|
|
Usage: "Custom node name",
|
2015-04-18 14:53:30 -07:00
|
|
|
}
|
2015-04-08 04:22:31 -07:00
|
|
|
NatspecEnabledFlag = cli.BoolFlag{
|
|
|
|
Name: "natspec",
|
|
|
|
Usage: "Enable NatSpec confirmation notice",
|
|
|
|
}
|
2015-10-26 14:24:09 -07:00
|
|
|
DocRootFlag = DirectoryFlag{
|
|
|
|
Name: "docroot",
|
|
|
|
Usage: "Document Root for HTTPClient file scheme",
|
|
|
|
Value: DirectoryString{common.HomeDir()},
|
|
|
|
}
|
2015-07-22 03:46:20 -07:00
|
|
|
CacheFlag = cli.IntFlag{
|
|
|
|
Name: "cache",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Megabytes of memory allocated to internal caching (min 16MB / database forced)",
|
2015-07-22 03:46:20 -07:00
|
|
|
Value: 0,
|
|
|
|
}
|
2015-10-29 10:53:24 -07:00
|
|
|
BlockchainVersionFlag = cli.IntFlag{
|
|
|
|
Name: "blockchainversion",
|
|
|
|
Usage: "Blockchain version (integer)",
|
|
|
|
Value: core.BlockChainVersion,
|
2015-08-03 08:48:24 -07:00
|
|
|
}
|
2015-10-09 08:36:31 -07:00
|
|
|
FastSyncFlag = cli.BoolFlag{
|
|
|
|
Name: "fast",
|
2015-11-10 05:47:19 -08:00
|
|
|
Usage: "Enable fast syncing through state downloads",
|
2015-07-02 09:55:18 -07:00
|
|
|
}
|
2015-10-23 07:49:36 -07:00
|
|
|
LightKDFFlag = cli.BoolFlag{
|
|
|
|
Name: "lightkdf",
|
2015-11-10 05:47:19 -08:00
|
|
|
Usage: "Reduce key-derivation RAM & CPU usage at some expense of KDF strength",
|
2015-10-23 07:49:36 -07:00
|
|
|
}
|
2015-10-29 10:53:24 -07:00
|
|
|
// Miner settings
|
2015-06-11 22:45:23 -07:00
|
|
|
// TODO: refactor CPU vs GPU mining flags
|
2015-10-29 10:53:24 -07:00
|
|
|
MiningEnabledFlag = cli.BoolFlag{
|
|
|
|
Name: "mine",
|
|
|
|
Usage: "Enable mining",
|
2015-06-11 22:45:23 -07:00
|
|
|
}
|
2015-03-05 18:00:41 -08:00
|
|
|
MinerThreadsFlag = cli.IntFlag{
|
|
|
|
Name: "minerthreads",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Number of CPU threads to use for mining",
|
2015-03-05 18:00:41 -08:00
|
|
|
Value: runtime.NumCPU(),
|
|
|
|
}
|
2015-10-29 10:53:24 -07:00
|
|
|
MiningGPUFlag = cli.StringFlag{
|
|
|
|
Name: "minergpus",
|
|
|
|
Usage: "List of GPUs to use for mining (e.g. '0,1' will use the first two GPUs found)",
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2015-05-20 08:56:17 -07:00
|
|
|
AutoDAGFlag = cli.BoolFlag{
|
|
|
|
Name: "autodag",
|
|
|
|
Usage: "Enable automatic DAG pregeneration",
|
|
|
|
}
|
2015-03-26 14:49:22 -07:00
|
|
|
EtherbaseFlag = cli.StringFlag{
|
2015-03-27 04:14:00 -07:00
|
|
|
Name: "etherbase",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Public address for block mining rewards (default = first account created)",
|
2015-07-07 01:32:05 -07:00
|
|
|
Value: "0",
|
2015-03-26 14:49:22 -07:00
|
|
|
}
|
2015-05-09 03:00:51 -07:00
|
|
|
GasPriceFlag = cli.StringFlag{
|
|
|
|
Name: "gasprice",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Minimal gas price to accept for mining a transactions",
|
2015-08-02 17:46:34 -07:00
|
|
|
Value: new(big.Int).Mul(big.NewInt(50), common.Shannon).String(),
|
2015-05-09 03:00:51 -07:00
|
|
|
}
|
2015-09-22 01:34:58 -07:00
|
|
|
ExtraDataFlag = cli.StringFlag{
|
|
|
|
Name: "extradata",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Block extra data set by the miner (default = client version)",
|
2015-09-22 01:34:58 -07:00
|
|
|
}
|
2015-10-29 10:53:24 -07:00
|
|
|
// Account settings
|
2015-03-18 00:44:58 -07:00
|
|
|
UnlockedAccountFlag = cli.StringFlag{
|
|
|
|
Name: "unlock",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Unlock an account (may be creation index) until this program exits (prompts for password)",
|
2015-03-23 06:00:06 -07:00
|
|
|
Value: "",
|
|
|
|
}
|
|
|
|
PasswordFileFlag = cli.StringFlag{
|
|
|
|
Name: "password",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Password file to use with options/subcommands needing a pass phrase",
|
2015-03-23 06:00:06 -07:00
|
|
|
Value: "",
|
2015-03-18 00:44:58 -07:00
|
|
|
}
|
2015-03-05 18:00:41 -08:00
|
|
|
|
2015-07-17 14:09:36 -07:00
|
|
|
// vm flags
|
|
|
|
VMDebugFlag = cli.BoolFlag{
|
|
|
|
Name: "vmdebug",
|
|
|
|
Usage: "Virtual Machine debug output",
|
|
|
|
}
|
|
|
|
VMForceJitFlag = cli.BoolFlag{
|
|
|
|
Name: "forcejit",
|
|
|
|
Usage: "Force the JIT VM to take precedence",
|
|
|
|
}
|
|
|
|
VMJitCacheFlag = cli.IntFlag{
|
|
|
|
Name: "jitcache",
|
|
|
|
Usage: "Amount of cached JIT VM programs",
|
|
|
|
Value: 64,
|
|
|
|
}
|
|
|
|
VMEnableJitFlag = cli.BoolFlag{
|
|
|
|
Name: "jitvm",
|
|
|
|
Usage: "Enable the JIT VM",
|
|
|
|
}
|
|
|
|
|
2015-03-18 00:44:58 -07:00
|
|
|
// logging and debug settings
|
2015-05-09 03:00:51 -07:00
|
|
|
VerbosityFlag = cli.IntFlag{
|
|
|
|
Name: "verbosity",
|
2015-04-21 16:41:34 -07:00
|
|
|
Usage: "Logging verbosity: 0-6 (0=silent, 1=error, 2=warn, 3=info, 4=core, 5=debug, 6=debug detail)",
|
2015-03-05 18:00:41 -08:00
|
|
|
Value: int(logger.InfoLevel),
|
|
|
|
}
|
2015-10-29 10:53:24 -07:00
|
|
|
LogFileFlag = cli.StringFlag{
|
|
|
|
Name: "logfile",
|
|
|
|
Usage: "Log output file within the data dir (default = no log file generated)",
|
2015-03-21 02:20:47 -07:00
|
|
|
Value: "",
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2015-04-20 08:45:37 -07:00
|
|
|
LogVModuleFlag = cli.GenericFlag{
|
|
|
|
Name: "vmodule",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Per-module verbosity: comma-separated list of <module>=<level>, where <module> is file literal or a glog pattern",
|
2015-04-20 08:45:37 -07:00
|
|
|
Value: glog.GetVModule(),
|
|
|
|
}
|
|
|
|
BacktraceAtFlag = cli.GenericFlag{
|
2015-10-29 10:53:24 -07:00
|
|
|
Name: "backtrace",
|
|
|
|
Usage: "Request a stack trace at a specific logging statement (e.g. \"block.go:271\")",
|
2015-04-20 08:45:37 -07:00
|
|
|
Value: glog.GetTraceLocation(),
|
|
|
|
}
|
2015-04-20 09:14:49 -07:00
|
|
|
PProfEanbledFlag = cli.BoolFlag{
|
|
|
|
Name: "pprof",
|
2015-04-21 16:41:34 -07:00
|
|
|
Usage: "Enable the profiling server on localhost",
|
2015-04-20 08:45:37 -07:00
|
|
|
}
|
|
|
|
PProfPortFlag = cli.IntFlag{
|
|
|
|
Name: "pprofport",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Profile server listening port",
|
2015-04-20 08:45:37 -07:00
|
|
|
Value: 6060,
|
|
|
|
}
|
2015-06-29 06:11:01 -07:00
|
|
|
MetricsEnabledFlag = cli.BoolFlag{
|
|
|
|
Name: metrics.MetricsEnabledFlag,
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Enable metrics collection and reporting",
|
2015-06-29 06:11:01 -07:00
|
|
|
}
|
2015-03-05 18:00:41 -08:00
|
|
|
|
|
|
|
// RPC settings
|
|
|
|
RPCEnabledFlag = cli.BoolFlag{
|
|
|
|
Name: "rpc",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Enable the HTTP-RPC server",
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
|
|
|
RPCListenAddrFlag = cli.StringFlag{
|
|
|
|
Name: "rpcaddr",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "HTTP-RPC server listening interface",
|
2015-03-05 18:00:41 -08:00
|
|
|
Value: "127.0.0.1",
|
|
|
|
}
|
|
|
|
RPCPortFlag = cli.IntFlag{
|
|
|
|
Name: "rpcport",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "HTTP-RPC server listening port",
|
2015-03-05 18:00:41 -08:00
|
|
|
Value: 8545,
|
|
|
|
}
|
2015-03-29 12:21:14 -07:00
|
|
|
RPCCORSDomainFlag = cli.StringFlag{
|
|
|
|
Name: "rpccorsdomain",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Domains from which to accept cross origin requests (browser enforced)",
|
2015-03-29 12:21:14 -07:00
|
|
|
Value: "",
|
|
|
|
}
|
2015-06-16 04:30:53 -07:00
|
|
|
RpcApiFlag = cli.StringFlag{
|
|
|
|
Name: "rpcapi",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "API's offered over the HTTP-RPC interface",
|
2015-06-17 07:22:35 -07:00
|
|
|
Value: comms.DefaultHttpRpcApis,
|
2015-06-16 04:30:53 -07:00
|
|
|
}
|
2015-06-08 02:01:02 -07:00
|
|
|
IPCDisabledFlag = cli.BoolFlag{
|
|
|
|
Name: "ipcdisable",
|
|
|
|
Usage: "Disable the IPC-RPC server",
|
|
|
|
}
|
|
|
|
IPCApiFlag = cli.StringFlag{
|
|
|
|
Name: "ipcapi",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "API's offered over the IPC-RPC interface",
|
2015-06-17 07:22:35 -07:00
|
|
|
Value: comms.DefaultIpcApis,
|
2015-06-08 02:01:02 -07:00
|
|
|
}
|
|
|
|
IPCPathFlag = DirectoryFlag{
|
|
|
|
Name: "ipcpath",
|
|
|
|
Usage: "Filename for IPC socket/pipe",
|
|
|
|
Value: DirectoryString{common.DefaultIpcPath()},
|
|
|
|
}
|
2015-06-19 05:04:18 -07:00
|
|
|
ExecFlag = cli.StringFlag{
|
|
|
|
Name: "exec",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Execute JavaScript statement (only in combination with console/attach)",
|
2015-06-19 05:04:18 -07:00
|
|
|
}
|
2015-03-05 18:00:41 -08:00
|
|
|
// Network Settings
|
|
|
|
MaxPeersFlag = cli.IntFlag{
|
|
|
|
Name: "maxpeers",
|
2015-04-21 16:41:34 -07:00
|
|
|
Usage: "Maximum number of network peers (network disabled if set to 0)",
|
2015-05-08 07:01:31 -07:00
|
|
|
Value: 25,
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2015-05-04 07:35:49 -07:00
|
|
|
MaxPendingPeersFlag = cli.IntFlag{
|
|
|
|
Name: "maxpendpeers",
|
|
|
|
Usage: "Maximum number of pending connection attempts (defaults used if set to 0)",
|
|
|
|
Value: 0,
|
|
|
|
}
|
2015-03-05 18:00:41 -08:00
|
|
|
ListenPortFlag = cli.IntFlag{
|
|
|
|
Name: "port",
|
|
|
|
Usage: "Network listening port",
|
|
|
|
Value: 30303,
|
|
|
|
}
|
|
|
|
BootnodesFlag = cli.StringFlag{
|
|
|
|
Name: "bootnodes",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Space-separated enode URLs for P2P discovery bootstrap",
|
2015-03-05 18:00:41 -08:00
|
|
|
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",
|
2015-04-21 16:41:34 -07:00
|
|
|
Usage: "NAT port mapping mechanism (any|none|upnp|pmp|extip:<IP>)",
|
2015-03-05 18:00:41 -08:00
|
|
|
Value: "any",
|
|
|
|
}
|
2015-05-26 09:07:24 -07:00
|
|
|
NoDiscoverFlag = cli.BoolFlag{
|
|
|
|
Name: "nodiscover",
|
|
|
|
Usage: "Disables the peer discovery mechanism (manual peer addition)",
|
|
|
|
}
|
2015-04-20 08:45:37 -07:00
|
|
|
WhisperEnabledFlag = cli.BoolFlag{
|
|
|
|
Name: "shh",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Enable Whisper",
|
2015-04-20 08:45:37 -07:00
|
|
|
}
|
2015-04-22 15:11:11 -07:00
|
|
|
// ATM the url is left to the user and deployment to
|
2015-03-14 23:31:40 -07:00
|
|
|
JSpathFlag = cli.StringFlag{
|
|
|
|
Name: "jspath",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "JavaSript root path for `loadScript` and document root for `admin.httpGet`",
|
2015-03-14 23:31:40 -07:00
|
|
|
Value: ".",
|
|
|
|
}
|
2015-04-22 15:11:11 -07:00
|
|
|
SolcPathFlag = cli.StringFlag{
|
|
|
|
Name: "solc",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Solidity compiler command to be used",
|
2015-04-22 15:11:11 -07:00
|
|
|
Value: "solc",
|
|
|
|
}
|
2015-10-29 10:53:24 -07:00
|
|
|
|
|
|
|
// Gas price oracle settings
|
2015-05-26 05:17:43 -07:00
|
|
|
GpoMinGasPriceFlag = cli.StringFlag{
|
|
|
|
Name: "gpomin",
|
|
|
|
Usage: "Minimum suggested gas price",
|
2015-08-02 17:46:34 -07:00
|
|
|
Value: new(big.Int).Mul(big.NewInt(50), common.Shannon).String(),
|
2015-05-26 05:17:43 -07:00
|
|
|
}
|
|
|
|
GpoMaxGasPriceFlag = cli.StringFlag{
|
|
|
|
Name: "gpomax",
|
|
|
|
Usage: "Maximum suggested gas price",
|
2015-08-02 17:46:34 -07:00
|
|
|
Value: new(big.Int).Mul(big.NewInt(500), common.Shannon).String(),
|
2015-05-26 05:17:43 -07:00
|
|
|
}
|
|
|
|
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,
|
|
|
|
}
|
2015-03-05 18:00:41 -08:00
|
|
|
)
|
|
|
|
|
2015-05-27 05:50:31 -07:00
|
|
|
// MakeNAT creates a port mapper from set command line flags.
|
|
|
|
func MakeNAT(ctx *cli.Context) nat.Interface {
|
2015-03-05 18:00:41 -08:00
|
|
|
natif, err := nat.Parse(ctx.GlobalString(NATFlag.Name))
|
|
|
|
if err != nil {
|
|
|
|
Fatalf("Option %s: %v", NATFlag.Name, err)
|
|
|
|
}
|
|
|
|
return natif
|
|
|
|
}
|
|
|
|
|
2015-05-27 05:50:31 -07:00
|
|
|
// MakeNodeKey creates a node key from set command line flags.
|
|
|
|
func MakeNodeKey(ctx *cli.Context) (key *ecdsa.PrivateKey) {
|
2015-03-05 18:00:41 -08:00
|
|
|
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
|
|
|
|
}
|
|
|
|
|
2015-05-27 05:50:31 -07:00
|
|
|
// MakeEthConfig creates ethereum options from set command line flags.
|
2015-03-13 10:30:45 -07:00
|
|
|
func MakeEthConfig(clientID, version string, ctx *cli.Context) *eth.Config {
|
2015-04-18 14:53:30 -07:00
|
|
|
customName := ctx.GlobalString(IdentityFlag.Name)
|
|
|
|
if len(customName) > 0 {
|
|
|
|
clientID += "/" + customName
|
|
|
|
}
|
2015-07-07 01:32:05 -07:00
|
|
|
am := MakeAccountManager(ctx)
|
2015-07-07 03:53:36 -07:00
|
|
|
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")
|
|
|
|
}
|
2015-09-01 07:35:14 -07:00
|
|
|
// Assemble the entire eth configuration and return
|
2015-09-06 06:46:54 -07:00
|
|
|
cfg := ð.Config{
|
2015-05-26 05:17:43 -07:00
|
|
|
Name: common.MakeName(clientID, version),
|
2015-09-29 07:16:00 -07:00
|
|
|
DataDir: MustDataDir(ctx),
|
2015-07-10 05:29:40 -07:00
|
|
|
GenesisFile: ctx.GlobalString(GenesisFileFlag.Name),
|
2015-10-09 08:36:31 -07:00
|
|
|
FastSync: ctx.GlobalBool(FastSyncFlag.Name),
|
2015-05-26 05:17:43 -07:00
|
|
|
BlockChainVersion: ctx.GlobalInt(BlockchainVersionFlag.Name),
|
2015-07-22 03:46:20 -07:00
|
|
|
DatabaseCache: ctx.GlobalInt(CacheFlag.Name),
|
2015-05-26 05:17:43 -07:00
|
|
|
SkipBcVersionCheck: false,
|
|
|
|
NetworkId: ctx.GlobalInt(NetworkIdFlag.Name),
|
|
|
|
LogFile: ctx.GlobalString(LogFileFlag.Name),
|
|
|
|
Verbosity: ctx.GlobalInt(VerbosityFlag.Name),
|
2015-07-07 03:53:36 -07:00
|
|
|
Etherbase: common.HexToAddress(etherbase),
|
2015-05-26 05:17:43 -07:00
|
|
|
MinerThreads: ctx.GlobalInt(MinerThreadsFlag.Name),
|
2015-07-07 01:32:05 -07:00
|
|
|
AccountManager: am,
|
2015-05-26 05:17:43 -07:00
|
|
|
VmDebug: ctx.GlobalBool(VMDebugFlag.Name),
|
|
|
|
MaxPeers: ctx.GlobalInt(MaxPeersFlag.Name),
|
|
|
|
MaxPendingPeers: ctx.GlobalInt(MaxPendingPeersFlag.Name),
|
|
|
|
Port: ctx.GlobalString(ListenPortFlag.Name),
|
2015-08-03 08:48:24 -07:00
|
|
|
Olympic: ctx.GlobalBool(OlympicFlag.Name),
|
2015-05-26 05:17:43 -07:00
|
|
|
NAT: MakeNAT(ctx),
|
|
|
|
NatSpec: ctx.GlobalBool(NatspecEnabledFlag.Name),
|
2015-10-26 14:24:09 -07:00
|
|
|
DocRoot: ctx.GlobalString(DocRootFlag.Name),
|
2015-05-26 05:17:43 -07:00
|
|
|
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),
|
2015-03-13 10:30:45 -07:00
|
|
|
}
|
2015-09-06 06:46:54 -07:00
|
|
|
|
2015-10-05 04:01:34 -07:00
|
|
|
if ctx.GlobalBool(DevModeFlag.Name) && ctx.GlobalBool(TestNetFlag.Name) {
|
|
|
|
glog.Fatalf("%s and %s are mutually exclusive\n", DevModeFlag.Name, TestNetFlag.Name)
|
|
|
|
}
|
|
|
|
|
|
|
|
if ctx.GlobalBool(TestNetFlag.Name) {
|
|
|
|
// testnet is always stored in the testnet folder
|
|
|
|
cfg.DataDir += "/testnet"
|
|
|
|
cfg.NetworkId = 2
|
|
|
|
cfg.TestNet = true
|
|
|
|
}
|
|
|
|
|
2015-10-06 14:39:43 -07:00
|
|
|
if ctx.GlobalBool(VMEnableJitFlag.Name) {
|
|
|
|
cfg.Name += "/JIT"
|
|
|
|
}
|
2015-09-06 06:46:54 -07:00
|
|
|
if ctx.GlobalBool(DevModeFlag.Name) {
|
|
|
|
if !ctx.GlobalIsSet(VMDebugFlag.Name) {
|
|
|
|
cfg.VmDebug = true
|
|
|
|
}
|
|
|
|
if !ctx.GlobalIsSet(MaxPeersFlag.Name) {
|
|
|
|
cfg.MaxPeers = 0
|
|
|
|
}
|
|
|
|
if !ctx.GlobalIsSet(GasPriceFlag.Name) {
|
|
|
|
cfg.GasPrice = new(big.Int)
|
|
|
|
}
|
|
|
|
if !ctx.GlobalIsSet(ListenPortFlag.Name) {
|
|
|
|
cfg.Port = "0" // auto port
|
|
|
|
}
|
|
|
|
if !ctx.GlobalIsSet(WhisperEnabledFlag.Name) {
|
|
|
|
cfg.Shh = true
|
|
|
|
}
|
|
|
|
if !ctx.GlobalIsSet(DataDirFlag.Name) {
|
|
|
|
cfg.DataDir = os.TempDir() + "/ethereum_dev_mode"
|
|
|
|
}
|
|
|
|
cfg.PowTest = true
|
|
|
|
cfg.DevMode = true
|
|
|
|
|
|
|
|
glog.V(logger.Info).Infoln("dev mode enabled")
|
|
|
|
}
|
|
|
|
return cfg
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
|
|
|
|
2015-05-27 04:29:34 -07:00
|
|
|
// 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))
|
|
|
|
}
|
2015-04-13 01:13:52 -07:00
|
|
|
|
2015-10-07 08:21:13 -07:00
|
|
|
// SetupNetwork configures the system for either the main net or some test network.
|
|
|
|
func SetupNetwork(ctx *cli.Context) {
|
|
|
|
switch {
|
|
|
|
case ctx.GlobalBool(OlympicFlag.Name):
|
|
|
|
params.DurationLimit = big.NewInt(8)
|
|
|
|
params.GenesisGasLimit = big.NewInt(3141592)
|
|
|
|
params.MinGasLimit = big.NewInt(125000)
|
|
|
|
params.MaximumExtraDataSize = big.NewInt(1024)
|
|
|
|
NetworkIdFlag.Value = 0
|
|
|
|
core.BlockReward = big.NewInt(1.5e+18)
|
|
|
|
core.ExpDiffPeriod = big.NewInt(math.MaxInt64)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-17 14:09:36 -07:00
|
|
|
// SetupVM configured the VM package's global settings
|
|
|
|
func SetupVM(ctx *cli.Context) {
|
2015-08-10 15:27:30 -07:00
|
|
|
vm.EnableJit = ctx.GlobalBool(VMEnableJitFlag.Name)
|
2015-07-17 14:09:36 -07:00
|
|
|
vm.ForceJit = ctx.GlobalBool(VMForceJitFlag.Name)
|
|
|
|
vm.SetJITCacheSize(ctx.GlobalInt(VMJitCacheFlag.Name))
|
|
|
|
}
|
|
|
|
|
2015-05-27 05:50:31 -07:00
|
|
|
// MakeChain creates a chain manager from set command line flags.
|
2015-08-31 08:09:50 -07:00
|
|
|
func MakeChain(ctx *cli.Context) (chain *core.BlockChain, chainDb ethdb.Database) {
|
2015-09-29 07:16:00 -07:00
|
|
|
datadir := MustDataDir(ctx)
|
2015-07-22 03:46:20 -07:00
|
|
|
cache := ctx.GlobalInt(CacheFlag.Name)
|
|
|
|
|
2015-05-27 04:29:34 -07:00
|
|
|
var err error
|
2015-08-06 10:57:39 -07:00
|
|
|
if chainDb, err = ethdb.NewLDBDatabase(filepath.Join(datadir, "chaindata"), cache); err != nil {
|
2015-04-13 01:13:52 -07:00
|
|
|
Fatalf("Could not open database: %v", err)
|
|
|
|
}
|
2015-08-03 08:48:24 -07:00
|
|
|
if ctx.GlobalBool(OlympicFlag.Name) {
|
2015-08-06 10:57:39 -07:00
|
|
|
_, err := core.WriteTestNetGenesisBlock(chainDb, 42)
|
2015-08-03 08:48:24 -07:00
|
|
|
if err != nil {
|
|
|
|
glog.Fatalln(err)
|
|
|
|
}
|
|
|
|
}
|
2015-04-13 01:13:52 -07:00
|
|
|
|
|
|
|
eventMux := new(event.TypeMux)
|
2015-05-04 23:24:15 -07:00
|
|
|
pow := ethash.New()
|
2015-07-10 05:29:40 -07:00
|
|
|
//genesis := core.GenesisBlock(uint64(ctx.GlobalInt(GenesisNonceFlag.Name)), blockDB)
|
2015-08-31 08:09:50 -07:00
|
|
|
chain, err = core.NewBlockChain(chainDb, pow, eventMux)
|
2015-06-08 03:12:13 -07:00
|
|
|
if err != nil {
|
|
|
|
Fatalf("Could not start chainmanager: %v", err)
|
|
|
|
}
|
|
|
|
|
2015-08-06 10:57:39 -07:00
|
|
|
return chain, chainDb
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2015-03-07 03:39:52 -08:00
|
|
|
|
2015-05-27 05:50:31 -07:00
|
|
|
// MakeChain creates an account manager from set command line flags.
|
|
|
|
func MakeAccountManager(ctx *cli.Context) *accounts.Manager {
|
2015-09-29 07:16:00 -07:00
|
|
|
dataDir := MustDataDir(ctx)
|
2015-10-05 04:01:34 -07:00
|
|
|
if ctx.GlobalBool(TestNetFlag.Name) {
|
|
|
|
dataDir += "/testnet"
|
|
|
|
}
|
2015-10-23 07:49:36 -07:00
|
|
|
scryptN := crypto.StandardScryptN
|
|
|
|
scryptP := crypto.StandardScryptP
|
|
|
|
if ctx.GlobalBool(LightKDFFlag.Name) {
|
|
|
|
scryptN = crypto.LightScryptN
|
|
|
|
scryptP = crypto.LightScryptP
|
|
|
|
}
|
|
|
|
ks := crypto.NewKeyStorePassphrase(filepath.Join(dataDir, "keystore"), scryptN, scryptP)
|
2015-03-09 16:09:39 -07:00
|
|
|
return accounts.NewManager(ks)
|
2015-03-07 03:39:52 -08:00
|
|
|
}
|
2015-03-09 15:00:27 -07:00
|
|
|
|
2015-09-29 07:16:00 -07:00
|
|
|
// MustDataDir retrieves the currently requested data directory, terminating if
|
|
|
|
// none (or the empty string) is specified.
|
|
|
|
func MustDataDir(ctx *cli.Context) string {
|
|
|
|
if path := ctx.GlobalString(DataDirFlag.Name); path != "" {
|
|
|
|
return path
|
|
|
|
}
|
|
|
|
Fatalf("Cannot determine default data directory, please set manually (--datadir)")
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
2015-06-12 00:32:37 -07:00
|
|
|
func IpcSocketPath(ctx *cli.Context) (ipcpath string) {
|
2015-08-06 07:15:36 -07:00
|
|
|
if runtime.GOOS == "windows" {
|
2015-06-12 00:32:37 -07:00
|
|
|
ipcpath = common.DefaultIpcPath()
|
2015-07-02 08:20:58 -07:00
|
|
|
if ctx.GlobalIsSet(IPCPathFlag.Name) {
|
2015-06-12 00:32:37 -07:00
|
|
|
ipcpath = ctx.GlobalString(IPCPathFlag.Name)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ipcpath = common.DefaultIpcPath()
|
2015-07-02 08:20:58 -07:00
|
|
|
if ctx.GlobalIsSet(DataDirFlag.Name) {
|
2015-06-12 00:32:37 -07:00
|
|
|
ipcpath = filepath.Join(ctx.GlobalString(DataDirFlag.Name), "geth.ipc")
|
|
|
|
}
|
2015-07-02 08:20:58 -07:00
|
|
|
if ctx.GlobalIsSet(IPCPathFlag.Name) {
|
|
|
|
ipcpath = ctx.GlobalString(IPCPathFlag.Name)
|
|
|
|
}
|
2015-06-12 00:32:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2015-06-08 02:01:02 -07:00
|
|
|
func StartIPC(eth *eth.Ethereum, ctx *cli.Context) error {
|
|
|
|
config := comms.IpcConfig{
|
2015-06-12 00:32:37 -07:00
|
|
|
Endpoint: IpcSocketPath(ctx),
|
2015-06-08 02:01:02 -07:00
|
|
|
}
|
|
|
|
|
2015-10-29 05:28:00 -07:00
|
|
|
initializer := func(conn net.Conn) (comms.Stopper, shared.EthereumApi, error) {
|
2015-08-07 00:56:49 -07:00
|
|
|
fe := useragent.NewRemoteFrontend(conn, eth.AccountManager())
|
|
|
|
xeth := xeth.New(eth, fe)
|
2015-10-29 05:28:00 -07:00
|
|
|
apis, err := api.ParseApiString(ctx.GlobalString(IPCApiFlag.Name), codec.JSON, xeth, eth)
|
2015-08-07 00:56:49 -07:00
|
|
|
if err != nil {
|
2015-10-29 05:28:00 -07:00
|
|
|
return nil, nil, err
|
2015-08-07 00:56:49 -07:00
|
|
|
}
|
2015-10-29 05:28:00 -07:00
|
|
|
return xeth, api.Merge(apis...), nil
|
2015-06-08 02:01:02 -07:00
|
|
|
}
|
|
|
|
|
2015-08-07 00:56:49 -07:00
|
|
|
return comms.StartIpc(config, codec.JSON, initializer)
|
2015-06-08 02:01:02 -07:00
|
|
|
}
|
|
|
|
|
2015-04-21 16:47:17 -07:00
|
|
|
func StartRPC(eth *eth.Ethereum, ctx *cli.Context) error {
|
2015-06-16 04:30:53 -07:00
|
|
|
config := comms.HttpConfig{
|
2015-03-29 12:26:47 -07:00
|
|
|
ListenAddress: ctx.GlobalString(RPCListenAddrFlag.Name),
|
|
|
|
ListenPort: uint(ctx.GlobalInt(RPCPortFlag.Name)),
|
|
|
|
CorsDomain: ctx.GlobalString(RPCCORSDomainFlag.Name),
|
2015-03-09 15:00:27 -07:00
|
|
|
}
|
2015-03-29 12:26:47 -07:00
|
|
|
|
|
|
|
xeth := xeth.New(eth, nil)
|
2015-06-16 04:30:53 -07:00
|
|
|
codec := codec.JSON
|
|
|
|
|
2015-10-26 14:24:09 -07:00
|
|
|
apis, err := api.ParseApiString(ctx.GlobalString(RpcApiFlag.Name), codec, xeth, eth)
|
2015-06-16 04:30:53 -07:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2015-06-22 03:47:32 -07:00
|
|
|
return comms.StartHttp(config, codec, api.Merge(apis...))
|
2015-03-09 15:00:27 -07:00
|
|
|
}
|
2015-04-20 08:45:37 -07:00
|
|
|
|
|
|
|
func StartPProf(ctx *cli.Context) {
|
|
|
|
address := fmt.Sprintf("localhost:%d", ctx.GlobalInt(PProfPortFlag.Name))
|
|
|
|
go func() {
|
|
|
|
log.Println(http.ListenAndServe(address, nil))
|
|
|
|
}()
|
|
|
|
}
|
2015-07-07 01:32:05 -07:00
|
|
|
|
2015-07-07 03:53:36 -07:00
|
|
|
func ParamToAddress(addr string, am *accounts.Manager) (addrHex string, err error) {
|
2015-07-07 01:32:05 -07:00
|
|
|
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 {
|
2015-07-07 03:53:36 -07:00
|
|
|
return "", err
|
2015-07-07 01:32:05 -07:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
addrHex = addr
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|