2015-07-06 19:54:22 -05: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 11:48:40 -05:00
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2015-07-06 19:54:22 -05:00
|
|
|
// GNU General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU General Public License
|
2015-07-22 11:48:40 -05:00
|
|
|
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
2015-07-06 19:54:22 -05:00
|
|
|
|
2016-11-25 09:55:06 -06:00
|
|
|
// Package utils contains internal helper functions for go-ethereum commands.
|
2015-03-05 20:00:41 -06:00
|
|
|
package utils
|
|
|
|
|
|
|
|
import (
|
|
|
|
"crypto/ecdsa"
|
2015-04-20 10:45:37 -05:00
|
|
|
"fmt"
|
2015-11-17 10:33:25 -06:00
|
|
|
"io/ioutil"
|
2015-05-09 05:00:51 -05:00
|
|
|
"math/big"
|
2015-03-09 17:00:27 -05:00
|
|
|
"os"
|
2015-05-12 07:24:11 -05:00
|
|
|
"path/filepath"
|
2015-05-12 08:20:53 -05:00
|
|
|
"runtime"
|
2015-07-07 03:32:05 -05:00
|
|
|
"strconv"
|
2015-11-17 10:33:25 -06:00
|
|
|
"strings"
|
2015-05-12 07:24:11 -05:00
|
|
|
|
2015-04-13 03:13:52 -05:00
|
|
|
"github.com/ethereum/ethash"
|
2015-03-07 05:39:52 -06:00
|
|
|
"github.com/ethereum/go-ethereum/accounts"
|
2017-01-24 03:49:20 -06:00
|
|
|
"github.com/ethereum/go-ethereum/accounts/keystore"
|
2015-03-18 02:44:58 -05:00
|
|
|
"github.com/ethereum/go-ethereum/common"
|
2015-03-05 20:00:41 -06:00
|
|
|
"github.com/ethereum/go-ethereum/core"
|
2015-11-17 10:33:25 -06:00
|
|
|
"github.com/ethereum/go-ethereum/core/state"
|
2017-01-17 05:19:50 -06:00
|
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
2015-03-05 20:00:41 -06:00
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
"github.com/ethereum/go-ethereum/eth"
|
|
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
2016-11-25 09:55:06 -06:00
|
|
|
"github.com/ethereum/go-ethereum/ethstats"
|
2015-03-05 20:00:41 -06:00
|
|
|
"github.com/ethereum/go-ethereum/event"
|
2016-01-13 12:35:48 -06:00
|
|
|
"github.com/ethereum/go-ethereum/les"
|
2015-03-05 20:00:41 -06:00
|
|
|
"github.com/ethereum/go-ethereum/logger"
|
2015-04-03 10:09:01 -05:00
|
|
|
"github.com/ethereum/go-ethereum/logger/glog"
|
2015-08-07 02:56:49 -05:00
|
|
|
"github.com/ethereum/go-ethereum/metrics"
|
2015-11-17 10:33:25 -06:00
|
|
|
"github.com/ethereum/go-ethereum/node"
|
|
|
|
"github.com/ethereum/go-ethereum/p2p/discover"
|
2016-11-09 08:35:04 -06:00
|
|
|
"github.com/ethereum/go-ethereum/p2p/discv5"
|
2015-03-05 20:00:41 -06:00
|
|
|
"github.com/ethereum/go-ethereum/p2p/nat"
|
2016-11-22 13:52:31 -06:00
|
|
|
"github.com/ethereum/go-ethereum/p2p/netutil"
|
2015-10-07 10:21:13 -05:00
|
|
|
"github.com/ethereum/go-ethereum/params"
|
2016-04-21 04:14:57 -05:00
|
|
|
"github.com/ethereum/go-ethereum/pow"
|
2015-12-16 03:58:01 -06:00
|
|
|
"github.com/ethereum/go-ethereum/rpc"
|
2016-10-29 07:11:37 -05:00
|
|
|
whisper "github.com/ethereum/go-ethereum/whisper/whisperv2"
|
2016-06-09 04:44:42 -05:00
|
|
|
"gopkg.in/urfave/cli.v1"
|
2015-03-05 20:00:41 -06:00
|
|
|
)
|
|
|
|
|
2015-03-10 10:44:48 -05: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 16:51:50 -05:00
|
|
|
// NewApp creates an app with sane defaults.
|
2016-09-05 06:08:41 -05:00
|
|
|
func NewApp(gitCommit, usage string) *cli.App {
|
2015-03-09 16:51:50 -05:00
|
|
|
app := cli.NewApp()
|
2015-05-12 07:24:11 -05:00
|
|
|
app.Name = filepath.Base(os.Args[0])
|
2015-03-09 16:51:50 -05:00
|
|
|
app.Author = ""
|
2015-03-25 19:03:03 -05:00
|
|
|
//app.Authors = nil
|
2015-03-09 16:51:50 -05:00
|
|
|
app.Email = ""
|
2016-11-25 09:55:06 -06:00
|
|
|
app.Version = params.Version
|
2016-09-05 06:08:41 -05:00
|
|
|
if gitCommit != "" {
|
|
|
|
app.Version += "-" + gitCommit[:8]
|
|
|
|
}
|
2015-03-09 16:51:50 -05:00
|
|
|
app.Usage = usage
|
|
|
|
return app
|
|
|
|
}
|
|
|
|
|
2015-03-05 20:00:41 -06: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 08:43:55 -05:00
|
|
|
DataDirFlag = DirectoryFlag{
|
2015-03-05 20:00:41 -06:00
|
|
|
Name: "datadir",
|
2015-10-29 12:53:24 -05:00
|
|
|
Usage: "Data directory for the databases and keystore",
|
2016-09-16 04:53:50 -05:00
|
|
|
Value: DirectoryString{node.DefaultDataDir()},
|
2015-03-05 20:00:41 -06:00
|
|
|
}
|
2016-03-07 16:38:56 -06:00
|
|
|
KeyStoreDirFlag = DirectoryFlag{
|
|
|
|
Name: "keystore",
|
|
|
|
Usage: "Directory for the keystore (default = inside the datadir)",
|
|
|
|
}
|
2015-03-18 02:44:58 -05:00
|
|
|
NetworkIdFlag = cli.IntFlag{
|
|
|
|
Name: "networkid",
|
2017-01-09 05:09:37 -06:00
|
|
|
Usage: "Network identifier (integer, 1=Frontier, 2=Morden (disused), 3=Ropsten)",
|
2015-03-18 02:44:58 -05:00
|
|
|
Value: eth.NetworkId,
|
|
|
|
}
|
2015-10-29 12:53:24 -05:00
|
|
|
TestNetFlag = cli.BoolFlag{
|
|
|
|
Name: "testnet",
|
2016-11-29 08:23:11 -06:00
|
|
|
Usage: "Ropsten network: pre-configured test network",
|
2015-07-10 07:29:40 -05:00
|
|
|
}
|
2015-09-06 08:46:54 -05:00
|
|
|
DevModeFlag = cli.BoolFlag{
|
|
|
|
Name: "dev",
|
2015-10-29 12:53:24 -05:00
|
|
|
Usage: "Developer mode: pre-configured private network with several debugging flags",
|
2015-09-06 08:46:54 -05:00
|
|
|
}
|
2015-04-18 16:53:30 -05:00
|
|
|
IdentityFlag = cli.StringFlag{
|
|
|
|
Name: "identity",
|
2015-04-21 18:41:34 -05:00
|
|
|
Usage: "Custom node name",
|
2015-04-18 16:53:30 -05:00
|
|
|
}
|
2015-10-26 16:24:09 -05:00
|
|
|
DocRootFlag = DirectoryFlag{
|
|
|
|
Name: "docroot",
|
|
|
|
Usage: "Document Root for HTTPClient file scheme",
|
2016-09-16 04:53:50 -05:00
|
|
|
Value: DirectoryString{homeDir()},
|
2015-10-26 16:24:09 -05:00
|
|
|
}
|
2015-10-09 10:36:31 -05:00
|
|
|
FastSyncFlag = cli.BoolFlag{
|
|
|
|
Name: "fast",
|
2015-11-10 07:47:19 -06:00
|
|
|
Usage: "Enable fast syncing through state downloads",
|
2015-07-02 11:55:18 -05:00
|
|
|
}
|
2016-01-13 12:35:48 -06:00
|
|
|
LightModeFlag = cli.BoolFlag{
|
|
|
|
Name: "light",
|
|
|
|
Usage: "Enable light client mode",
|
|
|
|
}
|
|
|
|
LightServFlag = cli.IntFlag{
|
|
|
|
Name: "lightserv",
|
|
|
|
Usage: "Maximum percentage of time allowed for serving LES requests (0-90)",
|
|
|
|
Value: 0,
|
|
|
|
}
|
|
|
|
LightPeersFlag = cli.IntFlag{
|
|
|
|
Name: "lightpeers",
|
|
|
|
Usage: "Maximum number of LES client peers",
|
|
|
|
Value: 20,
|
|
|
|
}
|
2015-10-23 09:49:36 -05:00
|
|
|
LightKDFFlag = cli.BoolFlag{
|
|
|
|
Name: "lightkdf",
|
2015-11-10 07:47:19 -06:00
|
|
|
Usage: "Reduce key-derivation RAM & CPU usage at some expense of KDF strength",
|
2015-10-23 09:49:36 -05:00
|
|
|
}
|
2016-10-19 06:55:13 -05:00
|
|
|
// Performance tuning settings
|
|
|
|
CacheFlag = cli.IntFlag{
|
|
|
|
Name: "cache",
|
|
|
|
Usage: "Megabytes of memory allocated to internal caching (min 16MB / database forced)",
|
|
|
|
Value: 128,
|
|
|
|
}
|
|
|
|
TrieCacheGenFlag = cli.IntFlag{
|
|
|
|
Name: "trie-cache-gens",
|
|
|
|
Usage: "Number of trie node generations to keep in memory",
|
|
|
|
Value: int(state.MaxTrieCacheGen),
|
|
|
|
}
|
2015-10-29 12:53:24 -05:00
|
|
|
// Miner settings
|
|
|
|
MiningEnabledFlag = cli.BoolFlag{
|
|
|
|
Name: "mine",
|
|
|
|
Usage: "Enable mining",
|
2015-06-12 00:45:23 -05:00
|
|
|
}
|
2015-03-05 20:00:41 -06:00
|
|
|
MinerThreadsFlag = cli.IntFlag{
|
|
|
|
Name: "minerthreads",
|
2015-10-29 12:53:24 -05:00
|
|
|
Usage: "Number of CPU threads to use for mining",
|
2015-03-05 20:00:41 -06:00
|
|
|
Value: runtime.NumCPU(),
|
|
|
|
}
|
2016-03-01 16:32:43 -06:00
|
|
|
TargetGasLimitFlag = cli.StringFlag{
|
|
|
|
Name: "targetgaslimit",
|
|
|
|
Usage: "Target gas limit sets the artificial target gas floor for the blocks to mine",
|
|
|
|
Value: params.GenesisGasLimit.String(),
|
|
|
|
}
|
2015-05-20 10:56:17 -05:00
|
|
|
AutoDAGFlag = cli.BoolFlag{
|
|
|
|
Name: "autodag",
|
|
|
|
Usage: "Enable automatic DAG pregeneration",
|
|
|
|
}
|
2015-03-26 16:49:22 -05:00
|
|
|
EtherbaseFlag = cli.StringFlag{
|
2015-03-27 06:14:00 -05:00
|
|
|
Name: "etherbase",
|
2015-10-29 12:53:24 -05:00
|
|
|
Usage: "Public address for block mining rewards (default = first account created)",
|
2015-07-07 03:32:05 -05:00
|
|
|
Value: "0",
|
2015-03-26 16:49:22 -05:00
|
|
|
}
|
2015-05-09 05:00:51 -05:00
|
|
|
GasPriceFlag = cli.StringFlag{
|
|
|
|
Name: "gasprice",
|
2015-10-29 12:53:24 -05:00
|
|
|
Usage: "Minimal gas price to accept for mining a transactions",
|
2016-02-29 07:15:18 -06:00
|
|
|
Value: new(big.Int).Mul(big.NewInt(20), common.Shannon).String(),
|
2015-05-09 05:00:51 -05:00
|
|
|
}
|
2015-09-22 03:34:58 -05:00
|
|
|
ExtraDataFlag = cli.StringFlag{
|
|
|
|
Name: "extradata",
|
2015-10-29 12:53:24 -05:00
|
|
|
Usage: "Block extra data set by the miner (default = client version)",
|
2015-09-22 03:34:58 -05:00
|
|
|
}
|
2015-10-29 12:53:24 -05:00
|
|
|
// Account settings
|
2015-03-18 02:44:58 -05:00
|
|
|
UnlockedAccountFlag = cli.StringFlag{
|
|
|
|
Name: "unlock",
|
2015-11-17 10:33:25 -06:00
|
|
|
Usage: "Comma separated list of accounts to unlock",
|
2015-03-23 08:00:06 -05:00
|
|
|
Value: "",
|
|
|
|
}
|
|
|
|
PasswordFileFlag = cli.StringFlag{
|
|
|
|
Name: "password",
|
2015-11-17 10:33:25 -06:00
|
|
|
Usage: "Password file to use for non-inteactive password input",
|
2015-03-23 08:00:06 -05:00
|
|
|
Value: "",
|
2015-03-18 02:44:58 -05:00
|
|
|
}
|
2015-03-05 20:00:41 -06:00
|
|
|
|
2015-07-17 16:09:36 -05:00
|
|
|
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",
|
|
|
|
}
|
2017-01-17 05:19:50 -06:00
|
|
|
VMEnableDebugFlag = cli.BoolFlag{
|
|
|
|
Name: "vmdebug",
|
|
|
|
Usage: "Record information useful for VM and contract debugging",
|
|
|
|
}
|
2016-11-25 09:55:06 -06:00
|
|
|
// Logging and debug settings
|
|
|
|
EthStatsURLFlag = cli.StringFlag{
|
|
|
|
Name: "ethstats",
|
|
|
|
Usage: "Reporting URL of a ethstats service (nodename:secret@host:port)",
|
|
|
|
}
|
2015-06-29 08:11:01 -05:00
|
|
|
MetricsEnabledFlag = cli.BoolFlag{
|
|
|
|
Name: metrics.MetricsEnabledFlag,
|
2015-10-29 12:53:24 -05:00
|
|
|
Usage: "Enable metrics collection and reporting",
|
2015-06-29 08:11:01 -05:00
|
|
|
}
|
2016-04-21 04:14:57 -05:00
|
|
|
FakePoWFlag = cli.BoolFlag{
|
|
|
|
Name: "fakepow",
|
|
|
|
Usage: "Disables proof-of-work verification",
|
|
|
|
}
|
2015-03-05 20:00:41 -06:00
|
|
|
|
|
|
|
// RPC settings
|
|
|
|
RPCEnabledFlag = cli.BoolFlag{
|
|
|
|
Name: "rpc",
|
2015-10-29 12:53:24 -05:00
|
|
|
Usage: "Enable the HTTP-RPC server",
|
2015-03-05 20:00:41 -06:00
|
|
|
}
|
|
|
|
RPCListenAddrFlag = cli.StringFlag{
|
|
|
|
Name: "rpcaddr",
|
2015-10-29 12:53:24 -05:00
|
|
|
Usage: "HTTP-RPC server listening interface",
|
2016-09-16 04:53:50 -05:00
|
|
|
Value: node.DefaultHTTPHost,
|
2015-03-05 20:00:41 -06:00
|
|
|
}
|
|
|
|
RPCPortFlag = cli.IntFlag{
|
|
|
|
Name: "rpcport",
|
2015-10-29 12:53:24 -05:00
|
|
|
Usage: "HTTP-RPC server listening port",
|
2016-09-16 04:53:50 -05:00
|
|
|
Value: node.DefaultHTTPPort,
|
2015-03-05 20:00:41 -06:00
|
|
|
}
|
2015-03-29 14:21:14 -05:00
|
|
|
RPCCORSDomainFlag = cli.StringFlag{
|
|
|
|
Name: "rpccorsdomain",
|
2016-02-24 04:19:00 -06:00
|
|
|
Usage: "Comma separated list of domains from which to accept cross origin requests (browser enforced)",
|
2015-03-29 14:21:14 -05:00
|
|
|
Value: "",
|
|
|
|
}
|
2015-12-16 03:58:01 -06:00
|
|
|
RPCApiFlag = cli.StringFlag{
|
2015-06-16 06:30:53 -05:00
|
|
|
Name: "rpcapi",
|
2015-10-29 12:53:24 -05:00
|
|
|
Usage: "API's offered over the HTTP-RPC interface",
|
2016-02-09 05:24:42 -06:00
|
|
|
Value: rpc.DefaultHTTPApis,
|
2015-06-16 06:30:53 -05:00
|
|
|
}
|
2015-06-08 04:01:02 -05:00
|
|
|
IPCDisabledFlag = cli.BoolFlag{
|
|
|
|
Name: "ipcdisable",
|
|
|
|
Usage: "Disable the IPC-RPC server",
|
|
|
|
}
|
|
|
|
IPCApiFlag = cli.StringFlag{
|
|
|
|
Name: "ipcapi",
|
2016-09-16 04:53:50 -05:00
|
|
|
Usage: "APIs offered over the IPC-RPC interface",
|
2016-02-09 05:24:42 -06:00
|
|
|
Value: rpc.DefaultIPCApis,
|
2015-06-08 04:01:02 -05:00
|
|
|
}
|
|
|
|
IPCPathFlag = DirectoryFlag{
|
|
|
|
Name: "ipcpath",
|
2016-02-02 11:06:43 -06:00
|
|
|
Usage: "Filename for IPC socket/pipe within the datadir (explicit paths escape it)",
|
2016-09-16 04:53:50 -05:00
|
|
|
Value: DirectoryString{"geth.ipc"},
|
2015-06-08 04:01:02 -05:00
|
|
|
}
|
2015-12-16 03:58:01 -06:00
|
|
|
WSEnabledFlag = cli.BoolFlag{
|
2016-01-26 07:39:21 -06:00
|
|
|
Name: "ws",
|
2015-12-16 03:58:01 -06:00
|
|
|
Usage: "Enable the WS-RPC server",
|
|
|
|
}
|
|
|
|
WSListenAddrFlag = cli.StringFlag{
|
|
|
|
Name: "wsaddr",
|
|
|
|
Usage: "WS-RPC server listening interface",
|
2016-09-16 04:53:50 -05:00
|
|
|
Value: node.DefaultWSHost,
|
2015-12-16 03:58:01 -06:00
|
|
|
}
|
|
|
|
WSPortFlag = cli.IntFlag{
|
|
|
|
Name: "wsport",
|
|
|
|
Usage: "WS-RPC server listening port",
|
2016-09-16 04:53:50 -05:00
|
|
|
Value: node.DefaultWSPort,
|
2015-12-16 03:58:01 -06:00
|
|
|
}
|
|
|
|
WSApiFlag = cli.StringFlag{
|
|
|
|
Name: "wsapi",
|
|
|
|
Usage: "API's offered over the WS-RPC interface",
|
2016-02-09 05:24:42 -06:00
|
|
|
Value: rpc.DefaultHTTPApis,
|
2015-12-16 03:58:01 -06:00
|
|
|
}
|
2016-03-14 03:38:54 -05:00
|
|
|
WSAllowedOriginsFlag = cli.StringFlag{
|
|
|
|
Name: "wsorigins",
|
|
|
|
Usage: "Origins from which to accept websockets requests",
|
2015-12-16 03:58:01 -06:00
|
|
|
Value: "",
|
2015-10-15 09:07:19 -05:00
|
|
|
}
|
2015-06-19 07:04:18 -05:00
|
|
|
ExecFlag = cli.StringFlag{
|
|
|
|
Name: "exec",
|
2015-10-29 12:53:24 -05:00
|
|
|
Usage: "Execute JavaScript statement (only in combination with console/attach)",
|
2015-06-19 07:04:18 -05:00
|
|
|
}
|
2016-05-06 04:40:23 -05:00
|
|
|
PreloadJSFlag = cli.StringFlag{
|
2016-04-07 06:48:24 -05:00
|
|
|
Name: "preload",
|
|
|
|
Usage: "Comma separated list of JavaScript files to preload into the console",
|
|
|
|
}
|
2016-01-26 07:39:21 -06:00
|
|
|
|
2015-03-05 20:00:41 -06:00
|
|
|
// Network Settings
|
|
|
|
MaxPeersFlag = cli.IntFlag{
|
|
|
|
Name: "maxpeers",
|
2015-04-21 18:41:34 -05:00
|
|
|
Usage: "Maximum number of network peers (network disabled if set to 0)",
|
2015-05-08 09:01:31 -05:00
|
|
|
Value: 25,
|
2015-03-05 20:00:41 -06:00
|
|
|
}
|
2015-05-04 09:35:49 -05:00
|
|
|
MaxPendingPeersFlag = cli.IntFlag{
|
|
|
|
Name: "maxpendpeers",
|
|
|
|
Usage: "Maximum number of pending connection attempts (defaults used if set to 0)",
|
|
|
|
Value: 0,
|
|
|
|
}
|
2015-03-05 20:00:41 -06:00
|
|
|
ListenPortFlag = cli.IntFlag{
|
|
|
|
Name: "port",
|
|
|
|
Usage: "Network listening port",
|
|
|
|
Value: 30303,
|
|
|
|
}
|
2017-01-10 14:11:34 -06:00
|
|
|
BootnodesFlag = cli.StringFlag{
|
2015-03-05 20:00:41 -06:00
|
|
|
Name: "bootnodes",
|
2015-11-17 10:33:25 -06:00
|
|
|
Usage: "Comma separated enode URLs for P2P discovery bootstrap",
|
2017-01-10 14:11:34 -06:00
|
|
|
Value: "",
|
2015-03-05 20:00:41 -06:00
|
|
|
}
|
|
|
|
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 18:41:34 -05:00
|
|
|
Usage: "NAT port mapping mechanism (any|none|upnp|pmp|extip:<IP>)",
|
2015-03-05 20:00:41 -06:00
|
|
|
Value: "any",
|
|
|
|
}
|
2015-05-26 11:07:24 -05:00
|
|
|
NoDiscoverFlag = cli.BoolFlag{
|
|
|
|
Name: "nodiscover",
|
|
|
|
Usage: "Disables the peer discovery mechanism (manual peer addition)",
|
|
|
|
}
|
2016-10-19 06:04:55 -05:00
|
|
|
DiscoveryV5Flag = cli.BoolFlag{
|
|
|
|
Name: "v5disc",
|
|
|
|
Usage: "Enables the experimental RLPx V5 (Topic Discovery) mechanism",
|
|
|
|
}
|
2016-11-22 13:52:31 -06:00
|
|
|
NetrestrictFlag = cli.StringFlag{
|
|
|
|
Name: "netrestrict",
|
|
|
|
Usage: "Restricts network communication to the given IP networks (CIDR masks)",
|
|
|
|
}
|
|
|
|
|
2015-04-20 10:45:37 -05:00
|
|
|
WhisperEnabledFlag = cli.BoolFlag{
|
|
|
|
Name: "shh",
|
2015-10-29 12:53:24 -05:00
|
|
|
Usage: "Enable Whisper",
|
2015-04-20 10:45:37 -05:00
|
|
|
}
|
2016-11-22 13:52:31 -06:00
|
|
|
|
2015-04-22 17:11:11 -05:00
|
|
|
// ATM the url is left to the user and deployment to
|
2015-03-15 01:31:40 -05:00
|
|
|
JSpathFlag = cli.StringFlag{
|
|
|
|
Name: "jspath",
|
2016-11-25 05:31:06 -06:00
|
|
|
Usage: "JavaScript root path for `loadScript`",
|
2015-03-15 01:31:40 -05:00
|
|
|
Value: ".",
|
|
|
|
}
|
2015-04-22 17:11:11 -05:00
|
|
|
SolcPathFlag = cli.StringFlag{
|
|
|
|
Name: "solc",
|
2015-10-29 12:53:24 -05:00
|
|
|
Usage: "Solidity compiler command to be used",
|
2015-04-22 17:11:11 -05:00
|
|
|
Value: "solc",
|
|
|
|
}
|
2015-10-29 12:53:24 -05:00
|
|
|
|
|
|
|
// Gas price oracle settings
|
2015-05-26 07:17:43 -05:00
|
|
|
GpoMinGasPriceFlag = cli.StringFlag{
|
|
|
|
Name: "gpomin",
|
|
|
|
Usage: "Minimum suggested gas price",
|
2016-02-29 07:15:18 -06:00
|
|
|
Value: new(big.Int).Mul(big.NewInt(20), common.Shannon).String(),
|
2015-05-26 07:17:43 -05:00
|
|
|
}
|
|
|
|
GpoMaxGasPriceFlag = cli.StringFlag{
|
|
|
|
Name: "gpomax",
|
|
|
|
Usage: "Maximum suggested gas price",
|
2015-08-02 19:46:34 -05:00
|
|
|
Value: new(big.Int).Mul(big.NewInt(500), common.Shannon).String(),
|
2015-05-26 07:17:43 -05: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 20:00:41 -06:00
|
|
|
)
|
|
|
|
|
2016-08-18 06:28:17 -05:00
|
|
|
// MakeDataDir retrieves the currently requested data directory, terminating
|
2015-11-17 10:33:25 -06:00
|
|
|
// if none (or the empty string) is specified. If the node is starting a testnet,
|
|
|
|
// the a subdirectory of the specified datadir will be used.
|
2016-08-18 06:28:17 -05:00
|
|
|
func MakeDataDir(ctx *cli.Context) string {
|
2015-11-17 10:33:25 -06:00
|
|
|
if path := ctx.GlobalString(DataDirFlag.Name); path != "" {
|
2016-08-18 06:28:17 -05:00
|
|
|
// TODO: choose a different location outside of the regular datadir.
|
2015-11-17 10:33:25 -06:00
|
|
|
if ctx.GlobalBool(TestNetFlag.Name) {
|
2016-08-18 06:28:17 -05:00
|
|
|
return filepath.Join(path, "testnet")
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
|
|
|
return path
|
2015-03-05 20:00:41 -06:00
|
|
|
}
|
2015-11-17 10:33:25 -06:00
|
|
|
Fatalf("Cannot determine default data directory, please set manually (--datadir)")
|
|
|
|
return ""
|
2015-03-05 20:00:41 -06:00
|
|
|
}
|
|
|
|
|
2016-02-09 05:24:42 -06:00
|
|
|
// MakeIPCPath creates an IPC path configuration from the set command line flags,
|
2016-02-02 11:06:43 -06:00
|
|
|
// returning an empty string if IPC was explicitly disabled, or the set path.
|
2016-02-09 05:24:42 -06:00
|
|
|
func MakeIPCPath(ctx *cli.Context) string {
|
2016-02-02 11:06:43 -06:00
|
|
|
if ctx.GlobalBool(IPCDisabledFlag.Name) {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return ctx.GlobalString(IPCPathFlag.Name)
|
|
|
|
}
|
|
|
|
|
2015-11-17 10:33:25 -06:00
|
|
|
// MakeNodeKey creates a node key from set command line flags, either loading it
|
|
|
|
// from a file or as a specified hex value. If neither flags were provided, this
|
|
|
|
// method returns nil and an emphemeral key is to be generated.
|
|
|
|
func MakeNodeKey(ctx *cli.Context) *ecdsa.PrivateKey {
|
|
|
|
var (
|
|
|
|
hex = ctx.GlobalString(NodeKeyHexFlag.Name)
|
|
|
|
file = ctx.GlobalString(NodeKeyFileFlag.Name)
|
|
|
|
|
|
|
|
key *ecdsa.PrivateKey
|
|
|
|
err error
|
|
|
|
)
|
2015-03-05 20:00:41 -06:00
|
|
|
switch {
|
|
|
|
case file != "" && hex != "":
|
|
|
|
Fatalf("Options %q and %q are mutually exclusive", NodeKeyFileFlag.Name, NodeKeyHexFlag.Name)
|
2015-11-17 10:33:25 -06:00
|
|
|
|
2015-03-05 20:00:41 -06:00
|
|
|
case file != "":
|
|
|
|
if key, err = crypto.LoadECDSA(file); err != nil {
|
|
|
|
Fatalf("Option %q: %v", NodeKeyFileFlag.Name, err)
|
|
|
|
}
|
2015-11-17 10:33:25 -06:00
|
|
|
|
2015-03-05 20:00:41 -06:00
|
|
|
case hex != "":
|
|
|
|
if key, err = crypto.HexToECDSA(hex); err != nil {
|
|
|
|
Fatalf("Option %q: %v", NodeKeyHexFlag.Name, err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return key
|
|
|
|
}
|
|
|
|
|
2016-08-18 06:28:17 -05:00
|
|
|
// makeNodeUserIdent creates the user identifier from CLI flags.
|
|
|
|
func makeNodeUserIdent(ctx *cli.Context) string {
|
|
|
|
var comps []string
|
2015-11-17 10:33:25 -06:00
|
|
|
if identity := ctx.GlobalString(IdentityFlag.Name); len(identity) > 0 {
|
2016-08-18 06:28:17 -05:00
|
|
|
comps = append(comps, identity)
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
|
|
|
if ctx.GlobalBool(VMEnableJitFlag.Name) {
|
2016-08-18 06:28:17 -05:00
|
|
|
comps = append(comps, "JIT")
|
2015-04-18 16:53:30 -05:00
|
|
|
}
|
2016-08-18 06:28:17 -05:00
|
|
|
return strings.Join(comps, "/")
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// MakeBootstrapNodes creates a list of bootstrap nodes from the command line
|
|
|
|
// flags, reverting to pre-configured ones if none have been specified.
|
|
|
|
func MakeBootstrapNodes(ctx *cli.Context) []*discover.Node {
|
2017-01-05 06:56:06 -06:00
|
|
|
urls := params.MainnetBootnodes
|
|
|
|
if ctx.GlobalIsSet(BootnodesFlag.Name) {
|
2017-01-10 14:11:34 -06:00
|
|
|
urls = strings.Split(ctx.GlobalString(BootnodesFlag.Name), ",")
|
2017-01-05 06:56:06 -06:00
|
|
|
} else if ctx.GlobalBool(TestNetFlag.Name) {
|
|
|
|
urls = params.TestnetBootnodes
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
|
|
|
|
2017-01-05 06:56:06 -06:00
|
|
|
bootnodes := make([]*discover.Node, 0, len(urls))
|
|
|
|
for _, url := range urls {
|
2015-11-17 10:33:25 -06:00
|
|
|
node, err := discover.ParseNode(url)
|
|
|
|
if err != nil {
|
|
|
|
glog.V(logger.Error).Infof("Bootstrap URL %s: %v\n", url, err)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
bootnodes = append(bootnodes, node)
|
|
|
|
}
|
|
|
|
return bootnodes
|
|
|
|
}
|
|
|
|
|
2016-11-09 08:35:04 -06:00
|
|
|
// MakeBootstrapNodesV5 creates a list of bootstrap nodes from the command line
|
|
|
|
// flags, reverting to pre-configured ones if none have been specified.
|
|
|
|
func MakeBootstrapNodesV5(ctx *cli.Context) []*discv5.Node {
|
2017-01-05 06:56:06 -06:00
|
|
|
urls := params.DiscoveryV5Bootnodes
|
|
|
|
if ctx.GlobalIsSet(BootnodesFlag.Name) {
|
2017-01-10 14:11:34 -06:00
|
|
|
urls = strings.Split(ctx.GlobalString(BootnodesFlag.Name), ",")
|
2016-11-09 08:35:04 -06:00
|
|
|
}
|
|
|
|
|
2017-01-05 06:56:06 -06:00
|
|
|
bootnodes := make([]*discv5.Node, 0, len(urls))
|
|
|
|
for _, url := range urls {
|
2016-11-09 08:35:04 -06:00
|
|
|
node, err := discv5.ParseNode(url)
|
|
|
|
if err != nil {
|
|
|
|
glog.V(logger.Error).Infof("Bootstrap URL %s: %v\n", url, err)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
bootnodes = append(bootnodes, node)
|
|
|
|
}
|
|
|
|
return bootnodes
|
|
|
|
}
|
|
|
|
|
2015-11-17 10:33:25 -06:00
|
|
|
// MakeListenAddress creates a TCP listening address string from set command
|
|
|
|
// line flags.
|
|
|
|
func MakeListenAddress(ctx *cli.Context) string {
|
|
|
|
return fmt.Sprintf(":%d", ctx.GlobalInt(ListenPortFlag.Name))
|
|
|
|
}
|
|
|
|
|
2016-11-09 08:35:04 -06:00
|
|
|
// MakeDiscoveryV5Address creates a UDP listening address string from set command
|
|
|
|
// line flags for the V5 discovery protocol.
|
|
|
|
func MakeDiscoveryV5Address(ctx *cli.Context) string {
|
2016-10-19 06:04:55 -05:00
|
|
|
return fmt.Sprintf(":%d", ctx.GlobalInt(ListenPortFlag.Name)+1)
|
|
|
|
}
|
|
|
|
|
2015-11-17 10:33:25 -06:00
|
|
|
// MakeNAT creates a port mapper from set command line flags.
|
|
|
|
func MakeNAT(ctx *cli.Context) nat.Interface {
|
|
|
|
natif, err := nat.Parse(ctx.GlobalString(NATFlag.Name))
|
2015-07-07 05:53:36 -05:00
|
|
|
if err != nil {
|
2015-11-17 10:33:25 -06:00
|
|
|
Fatalf("Option %s: %v", NATFlag.Name, err)
|
|
|
|
}
|
|
|
|
return natif
|
|
|
|
}
|
|
|
|
|
2016-04-14 09:18:35 -05:00
|
|
|
// MakeRPCModules splits input separated by a comma and trims excessive white
|
|
|
|
// space from the substrings.
|
|
|
|
func MakeRPCModules(input string) []string {
|
|
|
|
result := strings.Split(input, ",")
|
|
|
|
for i, r := range result {
|
|
|
|
result[i] = strings.TrimSpace(r)
|
|
|
|
}
|
|
|
|
return result
|
|
|
|
}
|
|
|
|
|
2016-02-09 05:24:42 -06:00
|
|
|
// MakeHTTPRpcHost creates the HTTP RPC listener interface string from the set
|
2016-02-05 05:45:36 -06:00
|
|
|
// command line flags, returning empty if the HTTP endpoint is disabled.
|
2016-02-09 05:24:42 -06:00
|
|
|
func MakeHTTPRpcHost(ctx *cli.Context) string {
|
2016-02-05 05:45:36 -06:00
|
|
|
if !ctx.GlobalBool(RPCEnabledFlag.Name) {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return ctx.GlobalString(RPCListenAddrFlag.Name)
|
|
|
|
}
|
|
|
|
|
2016-02-09 05:24:42 -06:00
|
|
|
// MakeWSRpcHost creates the WebSocket RPC listener interface string from the set
|
2016-02-05 07:08:48 -06:00
|
|
|
// command line flags, returning empty if the HTTP endpoint is disabled.
|
2016-02-09 05:24:42 -06:00
|
|
|
func MakeWSRpcHost(ctx *cli.Context) string {
|
2016-02-05 07:08:48 -06:00
|
|
|
if !ctx.GlobalBool(WSEnabledFlag.Name) {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return ctx.GlobalString(WSListenAddrFlag.Name)
|
|
|
|
}
|
|
|
|
|
2016-02-19 06:29:19 -06:00
|
|
|
// MakeDatabaseHandles raises out the number of allowed file handles per process
|
|
|
|
// for Geth and returns half of the allowance to assign to the database.
|
|
|
|
func MakeDatabaseHandles() int {
|
|
|
|
if err := raiseFdLimit(2048); err != nil {
|
|
|
|
Fatalf("Failed to raise file descriptor allowance: %v", err)
|
|
|
|
}
|
|
|
|
limit, err := getFdLimit()
|
|
|
|
if err != nil {
|
|
|
|
Fatalf("Failed to retrieve file descriptor allowance: %v", err)
|
|
|
|
}
|
|
|
|
if limit > 2048 { // cap database file descriptors even if more is available
|
|
|
|
limit = 2048
|
|
|
|
}
|
|
|
|
return limit / 2 // Leave half for networking and other stuff
|
|
|
|
}
|
|
|
|
|
2015-11-17 10:33:25 -06:00
|
|
|
// MakeAddress converts an account specified directly as a hex encoded string or
|
|
|
|
// a key index in the key store to an internal account representation.
|
2017-01-24 03:49:20 -06:00
|
|
|
func MakeAddress(ks *keystore.KeyStore, account string) (accounts.Account, error) {
|
2015-11-17 10:33:25 -06:00
|
|
|
// If the specified account is a valid address, return it
|
|
|
|
if common.IsHexAddress(account) {
|
2016-03-02 18:09:16 -06:00
|
|
|
return accounts.Account{Address: common.HexToAddress(account)}, nil
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
|
|
|
// Otherwise try to interpret the account as a keystore index
|
|
|
|
index, err := strconv.Atoi(account)
|
2017-01-24 03:49:20 -06:00
|
|
|
if err != nil || index < 0 {
|
2016-03-02 18:09:16 -06:00
|
|
|
return accounts.Account{}, fmt.Errorf("invalid account address or index %q", account)
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
2017-01-24 03:49:20 -06:00
|
|
|
accs := ks.Accounts()
|
|
|
|
if len(accs) <= index {
|
|
|
|
return accounts.Account{}, fmt.Errorf("index %d higher than number of accounts %d", index, len(accs))
|
|
|
|
}
|
|
|
|
return accs[index], nil
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// MakeEtherbase retrieves the etherbase either from the directly specified
|
|
|
|
// command line flags or from the keystore if CLI indexed.
|
2017-01-24 03:49:20 -06:00
|
|
|
func MakeEtherbase(ks *keystore.KeyStore, ctx *cli.Context) common.Address {
|
|
|
|
accounts := ks.Accounts()
|
2015-12-01 04:20:49 -06:00
|
|
|
if !ctx.GlobalIsSet(EtherbaseFlag.Name) && len(accounts) == 0 {
|
2015-07-07 05:53:36 -05:00
|
|
|
glog.V(logger.Error).Infoln("WARNING: No etherbase set and no accounts found as default")
|
2015-11-17 10:33:25 -06:00
|
|
|
return common.Address{}
|
|
|
|
}
|
2015-12-01 04:20:49 -06:00
|
|
|
etherbase := ctx.GlobalString(EtherbaseFlag.Name)
|
|
|
|
if etherbase == "" {
|
|
|
|
return common.Address{}
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
2015-12-01 04:20:49 -06:00
|
|
|
// If the specified etherbase is a valid address, return it
|
2017-01-24 03:49:20 -06:00
|
|
|
account, err := MakeAddress(ks, etherbase)
|
2015-11-17 10:33:25 -06:00
|
|
|
if err != nil {
|
2015-12-01 04:20:49 -06:00
|
|
|
Fatalf("Option %q: %v", EtherbaseFlag.Name, err)
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
2016-03-02 18:09:16 -06:00
|
|
|
return account.Address
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// MakeMinerExtra resolves extradata for the miner from the set command line flags
|
|
|
|
// or returns a default one composed on the client, runtime and OS metadata.
|
|
|
|
func MakeMinerExtra(extra []byte, ctx *cli.Context) []byte {
|
|
|
|
if ctx.GlobalIsSet(ExtraDataFlag.Name) {
|
|
|
|
return []byte(ctx.GlobalString(ExtraDataFlag.Name))
|
2015-07-07 05:53:36 -05:00
|
|
|
}
|
2015-11-17 10:33:25 -06:00
|
|
|
return extra
|
|
|
|
}
|
|
|
|
|
2016-03-30 16:20:06 -05:00
|
|
|
// MakePasswordList reads password lines from the file specified by --password.
|
2015-11-17 10:33:25 -06:00
|
|
|
func MakePasswordList(ctx *cli.Context) []string {
|
2016-03-30 16:20:06 -05:00
|
|
|
path := ctx.GlobalString(PasswordFileFlag.Name)
|
|
|
|
if path == "" {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
text, err := ioutil.ReadFile(path)
|
|
|
|
if err != nil {
|
|
|
|
Fatalf("Failed to read password file: %v", err)
|
|
|
|
}
|
|
|
|
lines := strings.Split(string(text), "\n")
|
|
|
|
// Sanitise DOS line endings.
|
|
|
|
for i := range lines {
|
|
|
|
lines[i] = strings.TrimRight(lines[i], "\r")
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
2016-03-30 16:20:06 -05:00
|
|
|
return lines
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
|
|
|
|
2016-08-15 11:38:32 -05:00
|
|
|
// MakeNode configures a node with no services from command line flags.
|
2016-09-05 06:08:41 -05:00
|
|
|
func MakeNode(ctx *cli.Context, name, gitCommit string) *node.Node {
|
2016-11-25 09:55:06 -06:00
|
|
|
vsn := params.Version
|
2016-09-05 06:08:41 -05:00
|
|
|
if gitCommit != "" {
|
|
|
|
vsn += "-" + gitCommit[:8]
|
|
|
|
}
|
|
|
|
|
2017-01-25 19:52:59 -06:00
|
|
|
// if we're running a light client or server, force enable the v5 peer discovery unless it is explicitly disabled with --nodiscover
|
|
|
|
// note that explicitly specifying --v5disc overrides --nodiscover, in which case the later only disables v4 discovery
|
|
|
|
forceV5Discovery := (ctx.GlobalBool(LightModeFlag.Name) || ctx.GlobalInt(LightServFlag.Name) > 0) && !ctx.GlobalBool(NoDiscoverFlag.Name)
|
|
|
|
|
2016-08-15 11:38:32 -05:00
|
|
|
config := &node.Config{
|
2016-08-18 06:28:17 -05:00
|
|
|
DataDir: MakeDataDir(ctx),
|
2016-08-15 11:38:32 -05:00
|
|
|
KeyStoreDir: ctx.GlobalString(KeyStoreDirFlag.Name),
|
|
|
|
UseLightweightKDF: ctx.GlobalBool(LightKDFFlag.Name),
|
|
|
|
PrivateKey: MakeNodeKey(ctx),
|
2016-08-18 06:28:17 -05:00
|
|
|
Name: name,
|
|
|
|
Version: vsn,
|
|
|
|
UserIdent: makeNodeUserIdent(ctx),
|
2017-01-25 19:52:59 -06:00
|
|
|
NoDiscovery: ctx.GlobalBool(NoDiscoverFlag.Name) || ctx.GlobalBool(LightModeFlag.Name), // always disable v4 discovery in light client mode
|
|
|
|
DiscoveryV5: ctx.GlobalBool(DiscoveryV5Flag.Name) || forceV5Discovery,
|
2016-11-09 08:35:04 -06:00
|
|
|
DiscoveryV5Addr: MakeDiscoveryV5Address(ctx),
|
2016-08-15 11:38:32 -05:00
|
|
|
BootstrapNodes: MakeBootstrapNodes(ctx),
|
2016-11-09 08:35:04 -06:00
|
|
|
BootstrapNodesV5: MakeBootstrapNodesV5(ctx),
|
2016-08-15 11:38:32 -05:00
|
|
|
ListenAddr: MakeListenAddress(ctx),
|
|
|
|
NAT: MakeNAT(ctx),
|
|
|
|
MaxPeers: ctx.GlobalInt(MaxPeersFlag.Name),
|
|
|
|
MaxPendingPeers: ctx.GlobalInt(MaxPendingPeersFlag.Name),
|
|
|
|
IPCPath: MakeIPCPath(ctx),
|
|
|
|
HTTPHost: MakeHTTPRpcHost(ctx),
|
|
|
|
HTTPPort: ctx.GlobalInt(RPCPortFlag.Name),
|
|
|
|
HTTPCors: ctx.GlobalString(RPCCORSDomainFlag.Name),
|
|
|
|
HTTPModules: MakeRPCModules(ctx.GlobalString(RPCApiFlag.Name)),
|
|
|
|
WSHost: MakeWSRpcHost(ctx),
|
|
|
|
WSPort: ctx.GlobalInt(WSPortFlag.Name),
|
|
|
|
WSOrigins: ctx.GlobalString(WSAllowedOriginsFlag.Name),
|
|
|
|
WSModules: MakeRPCModules(ctx.GlobalString(WSApiFlag.Name)),
|
|
|
|
}
|
|
|
|
if ctx.GlobalBool(DevModeFlag.Name) {
|
|
|
|
if !ctx.GlobalIsSet(DataDirFlag.Name) {
|
|
|
|
config.DataDir = filepath.Join(os.TempDir(), "/ethereum_dev_mode")
|
|
|
|
}
|
|
|
|
// --dev mode does not need p2p networking.
|
|
|
|
config.MaxPeers = 0
|
|
|
|
config.ListenAddr = ":0"
|
|
|
|
}
|
2016-11-22 13:52:31 -06:00
|
|
|
if netrestrict := ctx.GlobalString(NetrestrictFlag.Name); netrestrict != "" {
|
|
|
|
list, err := netutil.ParseNetlist(netrestrict)
|
|
|
|
if err != nil {
|
|
|
|
Fatalf("Option %q: %v", NetrestrictFlag.Name, err)
|
|
|
|
}
|
|
|
|
config.NetRestrict = list
|
|
|
|
}
|
|
|
|
|
2016-08-15 11:38:32 -05:00
|
|
|
stack, err := node.New(config)
|
|
|
|
if err != nil {
|
|
|
|
Fatalf("Failed to create the protocol stack: %v", err)
|
|
|
|
}
|
|
|
|
return stack
|
|
|
|
}
|
|
|
|
|
|
|
|
// RegisterEthService configures eth.Ethereum from command line flags and adds it to the
|
|
|
|
// given node.
|
2016-09-05 06:08:41 -05:00
|
|
|
func RegisterEthService(ctx *cli.Context, stack *node.Node, extra []byte) {
|
2015-11-17 10:33:25 -06:00
|
|
|
// Avoid conflicting network flags
|
2017-01-09 05:09:37 -06:00
|
|
|
networks, netFlags := 0, []cli.BoolFlag{DevModeFlag, TestNetFlag}
|
2015-11-17 10:33:25 -06:00
|
|
|
for _, flag := range netFlags {
|
|
|
|
if ctx.GlobalBool(flag.Name) {
|
|
|
|
networks++
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if networks > 1 {
|
|
|
|
Fatalf("The %v flags are mutually exclusive", netFlags)
|
|
|
|
}
|
2017-02-07 04:47:34 -06:00
|
|
|
ks := stack.AccountManager().Backends(keystore.KeyStoreType)[0].(*keystore.KeyStore)
|
2015-11-17 10:33:25 -06:00
|
|
|
|
|
|
|
ethConf := ð.Config{
|
2017-01-24 03:49:20 -06:00
|
|
|
Etherbase: MakeEtherbase(ks, ctx),
|
2016-08-18 06:28:17 -05:00
|
|
|
ChainConfig: MakeChainConfig(ctx, stack),
|
2015-10-09 10:36:31 -05:00
|
|
|
FastSync: ctx.GlobalBool(FastSyncFlag.Name),
|
2016-01-13 12:35:48 -06:00
|
|
|
LightMode: ctx.GlobalBool(LightModeFlag.Name),
|
|
|
|
LightServ: ctx.GlobalInt(LightServFlag.Name),
|
|
|
|
LightPeers: ctx.GlobalInt(LightPeersFlag.Name),
|
|
|
|
MaxPeers: ctx.GlobalInt(MaxPeersFlag.Name),
|
2015-07-22 05:46:20 -05:00
|
|
|
DatabaseCache: ctx.GlobalInt(CacheFlag.Name),
|
2016-02-19 06:29:19 -06:00
|
|
|
DatabaseHandles: MakeDatabaseHandles(),
|
2015-05-26 07:17:43 -05:00
|
|
|
NetworkId: ctx.GlobalInt(NetworkIdFlag.Name),
|
|
|
|
MinerThreads: ctx.GlobalInt(MinerThreadsFlag.Name),
|
2015-11-17 10:33:25 -06:00
|
|
|
ExtraData: MakeMinerExtra(extra, ctx),
|
2015-10-26 16:24:09 -05:00
|
|
|
DocRoot: ctx.GlobalString(DocRootFlag.Name),
|
2015-05-26 07:17:43 -05:00
|
|
|
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),
|
2017-01-17 05:19:50 -06:00
|
|
|
EnablePreimageRecording: ctx.GlobalBool(VMEnableDebugFlag.Name),
|
2015-03-13 12:30:45 -05:00
|
|
|
}
|
2015-09-06 08:46:54 -05:00
|
|
|
|
2015-11-17 10:33:25 -06:00
|
|
|
// Override any default configs in dev mode or the test net
|
|
|
|
switch {
|
|
|
|
case ctx.GlobalBool(TestNetFlag.Name):
|
|
|
|
if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
|
2016-11-20 15:32:31 -06:00
|
|
|
ethConf.NetworkId = 3
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
2016-11-20 15:32:31 -06:00
|
|
|
ethConf.Genesis = core.DefaultTestnetGenesisBlock()
|
2015-10-05 06:01:34 -05:00
|
|
|
|
2015-11-17 10:33:25 -06:00
|
|
|
case ctx.GlobalBool(DevModeFlag.Name):
|
2017-01-09 05:09:37 -06:00
|
|
|
ethConf.Genesis = core.DevGenesisBlock()
|
2015-11-17 10:33:25 -06:00
|
|
|
if !ctx.GlobalIsSet(GasPriceFlag.Name) {
|
|
|
|
ethConf.GasPrice = new(big.Int)
|
2015-09-06 08:46:54 -05:00
|
|
|
}
|
2015-11-17 10:33:25 -06:00
|
|
|
ethConf.PowTest = true
|
2015-09-06 08:46:54 -05:00
|
|
|
}
|
2016-10-19 06:55:13 -05:00
|
|
|
// Override any global options pertaining to the Ethereum protocol
|
|
|
|
if gen := ctx.GlobalInt(TrieCacheGenFlag.Name); gen > 0 {
|
|
|
|
state.MaxTrieCacheGen = uint16(gen)
|
|
|
|
}
|
2015-12-15 21:26:23 -06:00
|
|
|
|
2016-01-13 12:35:48 -06:00
|
|
|
if ethConf.LightMode {
|
|
|
|
if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
|
|
|
|
return les.New(ctx, ethConf)
|
|
|
|
}); err != nil {
|
|
|
|
Fatalf("Failed to register the Ethereum light node service: %v", err)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
|
|
|
|
fullNode, err := eth.New(ctx, ethConf)
|
|
|
|
if fullNode != nil && ethConf.LightServ > 0 {
|
|
|
|
ls, _ := les.NewLesServer(fullNode, ethConf)
|
|
|
|
fullNode.AddLesServer(ls)
|
|
|
|
}
|
|
|
|
return fullNode, err
|
|
|
|
}); err != nil {
|
|
|
|
Fatalf("Failed to register the Ethereum full node service: %v", err)
|
|
|
|
}
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
2016-08-15 11:38:32 -05:00
|
|
|
}
|
|
|
|
|
2016-11-25 09:55:06 -06:00
|
|
|
// RegisterShhService configures Whisper and adds it to the given node.
|
2016-08-15 11:38:32 -05:00
|
|
|
func RegisterShhService(stack *node.Node) {
|
|
|
|
if err := stack.Register(func(*node.ServiceContext) (node.Service, error) { return whisper.New(), nil }); err != nil {
|
|
|
|
Fatalf("Failed to register the Whisper service: %v", err)
|
|
|
|
}
|
2015-03-05 20:00:41 -06:00
|
|
|
}
|
|
|
|
|
2016-11-25 09:55:06 -06:00
|
|
|
// RegisterEthStatsService configures the Ethereum Stats daemon and adds it to
|
|
|
|
// th egiven node.
|
|
|
|
func RegisterEthStatsService(stack *node.Node, url string) {
|
|
|
|
if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
|
|
|
|
// Retrieve both eth and les services
|
|
|
|
var ethServ *eth.Ethereum
|
|
|
|
ctx.Service(ðServ)
|
|
|
|
|
|
|
|
var lesServ *les.LightEthereum
|
|
|
|
ctx.Service(&lesServ)
|
|
|
|
|
|
|
|
return ethstats.New(url, ethServ, lesServ)
|
|
|
|
}); err != nil {
|
|
|
|
Fatalf("Failed to register the Ethereum Stats service: %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-07 10:21:13 -05:00
|
|
|
// SetupNetwork configures the system for either the main net or some test network.
|
|
|
|
func SetupNetwork(ctx *cli.Context) {
|
2016-03-01 16:32:43 -06:00
|
|
|
params.TargetGasLimit = common.String2Big(ctx.GlobalString(TargetGasLimitFlag.Name))
|
2015-10-07 10:21:13 -05:00
|
|
|
}
|
|
|
|
|
2016-08-18 06:28:17 -05:00
|
|
|
// MakeChainConfig reads the chain configuration from the database in ctx.Datadir.
|
2016-10-20 06:36:29 -05:00
|
|
|
func MakeChainConfig(ctx *cli.Context, stack *node.Node) *params.ChainConfig {
|
2016-08-18 06:28:17 -05:00
|
|
|
db := MakeChainDatabase(ctx, stack)
|
2016-03-01 16:32:43 -06:00
|
|
|
defer db.Close()
|
|
|
|
|
2016-08-18 06:28:17 -05:00
|
|
|
return MakeChainConfigFromDb(ctx, db)
|
2016-04-07 04:25:28 -05:00
|
|
|
}
|
|
|
|
|
2016-08-18 06:28:17 -05:00
|
|
|
// MakeChainConfigFromDb reads the chain configuration from the given database.
|
2016-10-20 06:36:29 -05:00
|
|
|
func MakeChainConfigFromDb(ctx *cli.Context, db ethdb.Database) *params.ChainConfig {
|
2016-07-07 08:04:34 -05:00
|
|
|
// If the chain is already initialized, use any existing chain configs
|
2016-10-20 06:36:29 -05:00
|
|
|
config := new(params.ChainConfig)
|
2016-07-08 10:48:17 -05:00
|
|
|
|
2016-07-16 04:14:20 -05:00
|
|
|
genesis := core.GetBlock(db, core.GetCanonicalHash(db, 0), 0)
|
|
|
|
if genesis != nil {
|
2016-04-01 14:54:51 -05:00
|
|
|
storedConfig, err := core.GetChainConfig(db, genesis.Hash())
|
2016-07-08 10:48:17 -05:00
|
|
|
switch err {
|
|
|
|
case nil:
|
|
|
|
config = storedConfig
|
|
|
|
case core.ChainConfigNotFoundErr:
|
|
|
|
// No configs found, use empty, will populate below
|
|
|
|
default:
|
2016-03-01 16:32:43 -06:00
|
|
|
Fatalf("Could not make chain configuration: %v", err)
|
|
|
|
}
|
|
|
|
}
|
2016-11-02 07:44:13 -05:00
|
|
|
// set chain id in case it's zero.
|
|
|
|
if config.ChainId == nil {
|
|
|
|
config.ChainId = new(big.Int)
|
|
|
|
}
|
2016-10-29 05:33:57 -05:00
|
|
|
// Check whether we are allowed to set default config params or not:
|
|
|
|
// - If no genesis is set, we're running either mainnet or testnet (private nets use `geth init`)
|
|
|
|
// - If a genesis is already set, ensure we have a configuration for it (mainnet or testnet)
|
|
|
|
defaults := genesis == nil ||
|
|
|
|
(genesis.Hash() == params.MainNetGenesisHash && !ctx.GlobalBool(TestNetFlag.Name)) ||
|
|
|
|
(genesis.Hash() == params.TestNetGenesisHash && ctx.GlobalBool(TestNetFlag.Name))
|
|
|
|
|
|
|
|
if defaults {
|
2016-11-15 17:46:40 -06:00
|
|
|
if ctx.GlobalBool(TestNetFlag.Name) {
|
2016-11-20 15:32:31 -06:00
|
|
|
config = params.TestnetChainConfig
|
2016-11-15 17:46:40 -06:00
|
|
|
} else {
|
2016-11-20 15:32:31 -06:00
|
|
|
// Homestead fork
|
2016-11-15 17:46:40 -06:00
|
|
|
config.HomesteadBlock = params.MainNetHomesteadBlock
|
2016-11-20 15:32:31 -06:00
|
|
|
// DAO fork
|
2016-11-15 17:46:40 -06:00
|
|
|
config.DAOForkBlock = params.MainNetDAOForkBlock
|
2016-11-20 15:32:31 -06:00
|
|
|
config.DAOForkSupport = true
|
2016-11-15 17:46:40 -06:00
|
|
|
|
2016-11-20 15:32:31 -06:00
|
|
|
// DoS reprice fork
|
2016-11-15 17:46:40 -06:00
|
|
|
config.EIP150Block = params.MainNetHomesteadGasRepriceBlock
|
|
|
|
config.EIP150Hash = params.MainNetHomesteadGasRepriceHash
|
2016-11-20 15:32:31 -06:00
|
|
|
|
|
|
|
// DoS state cleanup fork
|
2016-11-15 17:46:40 -06:00
|
|
|
config.EIP155Block = params.MainNetSpuriousDragon
|
|
|
|
config.EIP158Block = params.MainNetSpuriousDragon
|
|
|
|
config.ChainId = params.MainNetChainID
|
2016-11-14 10:23:39 -06:00
|
|
|
}
|
2016-10-07 17:23:45 -05:00
|
|
|
}
|
2016-07-08 10:48:17 -05:00
|
|
|
return config
|
2015-07-17 16:09:36 -05:00
|
|
|
}
|
|
|
|
|
2016-01-13 12:35:48 -06:00
|
|
|
func ChainDbName(ctx *cli.Context) string {
|
|
|
|
if ctx.GlobalBool(LightModeFlag.Name) {
|
|
|
|
return "lightchaindata"
|
|
|
|
} else {
|
|
|
|
return "chaindata"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-01 16:32:43 -06:00
|
|
|
// MakeChainDatabase open an LevelDB using the flags passed to the client and will hard crash if it fails.
|
2016-08-18 06:28:17 -05:00
|
|
|
func MakeChainDatabase(ctx *cli.Context, stack *node.Node) ethdb.Database {
|
2016-03-01 16:32:43 -06:00
|
|
|
var (
|
|
|
|
cache = ctx.GlobalInt(CacheFlag.Name)
|
|
|
|
handles = MakeDatabaseHandles()
|
2016-01-13 12:35:48 -06:00
|
|
|
name = ChainDbName(ctx)
|
2016-03-01 16:32:43 -06:00
|
|
|
)
|
2015-07-22 05:46:20 -05:00
|
|
|
|
2016-01-13 12:35:48 -06:00
|
|
|
chainDb, err := stack.OpenDatabase(name, cache, handles)
|
2016-03-01 16:32:43 -06:00
|
|
|
if err != nil {
|
2015-04-13 03:13:52 -05:00
|
|
|
Fatalf("Could not open database: %v", err)
|
|
|
|
}
|
2016-03-01 16:32:43 -06:00
|
|
|
return chainDb
|
|
|
|
}
|
|
|
|
|
|
|
|
// MakeChain creates a chain manager from set command line flags.
|
2016-08-18 06:28:17 -05:00
|
|
|
func MakeChain(ctx *cli.Context, stack *node.Node) (chain *core.BlockChain, chainDb ethdb.Database) {
|
2016-03-01 16:32:43 -06:00
|
|
|
var err error
|
2016-08-18 06:28:17 -05:00
|
|
|
chainDb = MakeChainDatabase(ctx, stack)
|
2016-03-01 16:32:43 -06:00
|
|
|
|
2017-01-05 04:31:09 -06:00
|
|
|
if ctx.GlobalBool(TestNetFlag.Name) {
|
2015-11-17 10:33:25 -06:00
|
|
|
_, err := core.WriteTestNetGenesisBlock(chainDb)
|
2015-08-03 10:48:24 -05:00
|
|
|
if err != nil {
|
|
|
|
glog.Fatalln(err)
|
|
|
|
}
|
|
|
|
}
|
2017-01-05 04:31:09 -06:00
|
|
|
|
2016-08-18 06:28:17 -05:00
|
|
|
chainConfig := MakeChainConfigFromDb(ctx, chainDb)
|
2016-03-01 16:32:43 -06:00
|
|
|
|
2016-04-21 04:14:57 -05:00
|
|
|
pow := pow.PoW(core.FakePow{})
|
|
|
|
if !ctx.GlobalBool(FakePoWFlag.Name) {
|
|
|
|
pow = ethash.New()
|
|
|
|
}
|
2017-01-17 05:19:50 -06:00
|
|
|
chain, err = core.NewBlockChain(chainDb, chainConfig, pow, new(event.TypeMux), vm.Config{EnablePreimageRecording: ctx.GlobalBool(VMEnableDebugFlag.Name)})
|
2015-06-08 05:12:13 -05:00
|
|
|
if err != nil {
|
|
|
|
Fatalf("Could not start chainmanager: %v", err)
|
|
|
|
}
|
2015-08-06 12:57:39 -05:00
|
|
|
return chain, chainDb
|
2015-03-05 20:00:41 -06:00
|
|
|
}
|
2016-05-06 04:40:23 -05:00
|
|
|
|
|
|
|
// MakeConsolePreloads retrieves the absolute paths for the console JavaScript
|
|
|
|
// scripts to preload before starting.
|
|
|
|
func MakeConsolePreloads(ctx *cli.Context) []string {
|
|
|
|
// Skip preloading if there's nothing to preload
|
|
|
|
if ctx.GlobalString(PreloadJSFlag.Name) == "" {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
// Otherwise resolve absolute paths and return them
|
|
|
|
preloads := []string{}
|
|
|
|
|
|
|
|
assets := ctx.GlobalString(JSpathFlag.Name)
|
|
|
|
for _, file := range strings.Split(ctx.GlobalString(PreloadJSFlag.Name), ",") {
|
|
|
|
preloads = append(preloads, common.AbsolutePath(assets, strings.TrimSpace(file)))
|
|
|
|
}
|
|
|
|
return preloads
|
|
|
|
}
|