aboutsummaryrefslogtreecommitdiff
path: root/cmd/utils/flags.go
diff options
context:
space:
mode:
Diffstat (limited to 'cmd/utils/flags.go')
-rw-r--r--cmd/utils/flags.go1747
1 files changed, 1747 insertions, 0 deletions
diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go
new file mode 100644
index 0000000..7e28dff
--- /dev/null
+++ b/cmd/utils/flags.go
@@ -0,0 +1,1747 @@
+// 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
+// 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/>.
+
+// Package utils contains internal helper functions for go-ethereum commands.
+package utils
+
+import (
+ "crypto/ecdsa"
+ "errors"
+ "fmt"
+ "io/ioutil"
+ "math/big"
+ "os"
+ "path/filepath"
+ "strconv"
+ "strings"
+ "time"
+
+ "github.com/ethereum/go-ethereum/accounts"
+ "github.com/ethereum/go-ethereum/accounts/keystore"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/fdlimit"
+ "github.com/ethereum/go-ethereum/consensus"
+ "github.com/ethereum/go-ethereum/consensus/clique"
+ "github.com/ethereum/go-ethereum/consensus/ethash"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/dashboard"
+ "github.com/ethereum/go-ethereum/eth"
+ "github.com/ethereum/go-ethereum/eth/downloader"
+ "github.com/ethereum/go-ethereum/eth/gasprice"
+ "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/ethereum/go-ethereum/ethstats"
+ "github.com/ethereum/go-ethereum/graphql"
+ "github.com/ethereum/go-ethereum/les"
+ "github.com/ethereum/go-ethereum/log"
+ "github.com/ethereum/go-ethereum/metrics"
+ "github.com/ethereum/go-ethereum/metrics/influxdb"
+ "github.com/ethereum/go-ethereum/miner"
+ "github.com/ethereum/go-ethereum/node"
+ "github.com/ethereum/go-ethereum/p2p"
+ "github.com/ethereum/go-ethereum/p2p/discv5"
+ "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/ethereum/go-ethereum/p2p/nat"
+ "github.com/ethereum/go-ethereum/p2p/netutil"
+ "github.com/ethereum/go-ethereum/params"
+ "github.com/ethereum/go-ethereum/rpc"
+ whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
+ pcsclite "github.com/gballet/go-libpcsclite"
+ cli "gopkg.in/urfave/cli.v1"
+)
+
+var (
+ CommandHelpTemplate = `{{.cmd.Name}}{{if .cmd.Subcommands}} command{{end}}{{if .cmd.Flags}} [command options]{{end}} [arguments...]
+{{if .cmd.Description}}{{.cmd.Description}}
+{{end}}{{if .cmd.Subcommands}}
+SUBCOMMANDS:
+ {{range .cmd.Subcommands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}
+ {{end}}{{end}}{{if .categorizedFlags}}
+{{range $idx, $categorized := .categorizedFlags}}{{$categorized.Name}} OPTIONS:
+{{range $categorized.Flags}}{{"\t"}}{{.}}
+{{end}}
+{{end}}{{end}}`
+)
+
+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 = CommandHelpTemplate
+}
+
+// NewApp creates an app with sane defaults.
+func NewApp(gitCommit, gitDate, usage string) *cli.App {
+ app := cli.NewApp()
+ app.Name = filepath.Base(os.Args[0])
+ app.Author = ""
+ app.Email = ""
+ app.Version = params.VersionWithCommit(gitCommit, gitDate)
+ app.Usage = usage
+ return app
+}
+
+// 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
+ DataDirFlag = DirectoryFlag{
+ Name: "datadir",
+ Usage: "Data directory for the databases and keystore",
+ Value: DirectoryString{node.DefaultDataDir()},
+ }
+ AncientFlag = DirectoryFlag{
+ Name: "datadir.ancient",
+ Usage: "Data directory for ancient chain segments (default = inside chaindata)",
+ }
+ KeyStoreDirFlag = DirectoryFlag{
+ Name: "keystore",
+ Usage: "Directory for the keystore (default = inside the datadir)",
+ }
+ NoUSBFlag = cli.BoolFlag{
+ Name: "nousb",
+ Usage: "Disables monitoring for and managing USB hardware wallets",
+ }
+ SmartCardDaemonPathFlag = cli.StringFlag{
+ Name: "pcscdpath",
+ Usage: "Path to the smartcard daemon (pcscd) socket file",
+ Value: pcsclite.PCSCDSockName,
+ }
+ NetworkIdFlag = cli.Uint64Flag{
+ Name: "networkid",
+ Usage: "Network identifier (integer, 1=Frontier, 2=Morden (disused), 3=Ropsten, 4=Rinkeby)",
+ Value: eth.DefaultConfig.NetworkId,
+ }
+ TestnetFlag = cli.BoolFlag{
+ Name: "testnet",
+ Usage: "Ropsten network: pre-configured proof-of-work test network",
+ }
+ RinkebyFlag = cli.BoolFlag{
+ Name: "rinkeby",
+ Usage: "Rinkeby network: pre-configured proof-of-authority test network",
+ }
+ GoerliFlag = cli.BoolFlag{
+ Name: "goerli",
+ Usage: "Görli network: pre-configured proof-of-authority test network",
+ }
+ DeveloperFlag = cli.BoolFlag{
+ Name: "dev",
+ Usage: "Ephemeral proof-of-authority network with a pre-funded developer account, mining enabled",
+ }
+ DeveloperPeriodFlag = cli.IntFlag{
+ Name: "dev.period",
+ Usage: "Block period to use in developer mode (0 = mine only if transaction pending)",
+ }
+ IdentityFlag = cli.StringFlag{
+ Name: "identity",
+ Usage: "Custom node name",
+ }
+ DocRootFlag = DirectoryFlag{
+ Name: "docroot",
+ Usage: "Document Root for HTTPClient file scheme",
+ Value: DirectoryString{homeDir()},
+ }
+ ExitWhenSyncedFlag = cli.BoolFlag{
+ Name: "exitwhensynced",
+ Usage: "Exits after block synchronisation completes",
+ }
+ IterativeOutputFlag = cli.BoolFlag{
+ Name: "iterative",
+ Usage: "Print streaming JSON iteratively, delimited by newlines",
+ }
+ ExcludeStorageFlag = cli.BoolFlag{
+ Name: "nostorage",
+ Usage: "Exclude storage entries (save db lookups)",
+ }
+ IncludeIncompletesFlag = cli.BoolFlag{
+ Name: "incompletes",
+ Usage: "Include accounts for which we don't have the address (missing preimage)",
+ }
+ ExcludeCodeFlag = cli.BoolFlag{
+ Name: "nocode",
+ Usage: "Exclude contract code (save db lookups)",
+ }
+ defaultSyncMode = eth.DefaultConfig.SyncMode
+ SyncModeFlag = TextMarshalerFlag{
+ Name: "syncmode",
+ Usage: `Blockchain sync mode ("fast", "full", or "light")`,
+ Value: &defaultSyncMode,
+ }
+ GCModeFlag = cli.StringFlag{
+ Name: "gcmode",
+ Usage: `Blockchain garbage collection mode ("full", "archive")`,
+ Value: "full",
+ }
+ LightKDFFlag = cli.BoolFlag{
+ Name: "lightkdf",
+ Usage: "Reduce key-derivation RAM & CPU usage at some expense of KDF strength",
+ }
+ WhitelistFlag = cli.StringFlag{
+ Name: "whitelist",
+ Usage: "Comma separated block number-to-hash mappings to enforce (<number>=<hash>)",
+ }
+ // Light server and client settings
+ LightLegacyServFlag = cli.IntFlag{ // Deprecated in favor of light.serve, remove in 2021
+ Name: "lightserv",
+ Usage: "Maximum percentage of time allowed for serving LES requests (deprecated, use --light.serve)",
+ Value: eth.DefaultConfig.LightServ,
+ }
+ LightServeFlag = cli.IntFlag{
+ Name: "light.serve",
+ Usage: "Maximum percentage of time allowed for serving LES requests (multi-threaded processing allows values over 100)",
+ Value: eth.DefaultConfig.LightServ,
+ }
+ LightIngressFlag = cli.IntFlag{
+ Name: "light.ingress",
+ Usage: "Incoming bandwidth limit for serving light clients (kilobytes/sec, 0 = unlimited)",
+ Value: eth.DefaultConfig.LightIngress,
+ }
+ LightEgressFlag = cli.IntFlag{
+ Name: "light.egress",
+ Usage: "Outgoing bandwidth limit for serving light clients (kilobytes/sec, 0 = unlimited)",
+ Value: eth.DefaultConfig.LightEgress,
+ }
+ LightLegacyPeersFlag = cli.IntFlag{ // Deprecated in favor of light.maxpeers, remove in 2021
+ Name: "lightpeers",
+ Usage: "Maximum number of light clients to serve, or light servers to attach to (deprecated, use --light.maxpeers)",
+ Value: eth.DefaultConfig.LightPeers,
+ }
+ LightMaxPeersFlag = cli.IntFlag{
+ Name: "light.maxpeers",
+ Usage: "Maximum number of light clients to serve, or light servers to attach to",
+ Value: eth.DefaultConfig.LightPeers,
+ }
+ UltraLightServersFlag = cli.StringFlag{
+ Name: "ulc.servers",
+ Usage: "List of trusted ultra-light servers",
+ Value: strings.Join(eth.DefaultConfig.UltraLightServers, ","),
+ }
+ UltraLightFractionFlag = cli.IntFlag{
+ Name: "ulc.fraction",
+ Usage: "Minimum % of trusted ultra-light servers required to announce a new head",
+ Value: eth.DefaultConfig.UltraLightFraction,
+ }
+ UltraLightOnlyAnnounceFlag = cli.BoolFlag{
+ Name: "ulc.onlyannounce",
+ Usage: "Ultra light server sends announcements only",
+ }
+ // Dashboard settings
+ DashboardEnabledFlag = cli.BoolFlag{
+ Name: "dashboard",
+ Usage: "Enable the dashboard",
+ }
+ DashboardAddrFlag = cli.StringFlag{
+ Name: "dashboard.addr",
+ Usage: "Dashboard listening interface",
+ Value: dashboard.DefaultConfig.Host,
+ }
+ DashboardPortFlag = cli.IntFlag{
+ Name: "dashboard.host",
+ Usage: "Dashboard listening port",
+ Value: dashboard.DefaultConfig.Port,
+ }
+ DashboardRefreshFlag = cli.DurationFlag{
+ Name: "dashboard.refresh",
+ Usage: "Dashboard metrics collection refresh rate",
+ Value: dashboard.DefaultConfig.Refresh,
+ }
+ // Ethash settings
+ EthashCacheDirFlag = DirectoryFlag{
+ Name: "ethash.cachedir",
+ Usage: "Directory to store the ethash verification caches (default = inside the datadir)",
+ }
+ EthashCachesInMemoryFlag = cli.IntFlag{
+ Name: "ethash.cachesinmem",
+ Usage: "Number of recent ethash caches to keep in memory (16MB each)",
+ Value: eth.DefaultConfig.Ethash.CachesInMem,
+ }
+ EthashCachesOnDiskFlag = cli.IntFlag{
+ Name: "ethash.cachesondisk",
+ Usage: "Number of recent ethash caches to keep on disk (16MB each)",
+ Value: eth.DefaultConfig.Ethash.CachesOnDisk,
+ }
+ EthashDatasetDirFlag = DirectoryFlag{
+ Name: "ethash.dagdir",
+ Usage: "Directory to store the ethash mining DAGs (default = inside home folder)",
+ Value: DirectoryString{eth.DefaultConfig.Ethash.DatasetDir},
+ }
+ EthashDatasetsInMemoryFlag = cli.IntFlag{
+ Name: "ethash.dagsinmem",
+ Usage: "Number of recent ethash mining DAGs to keep in memory (1+GB each)",
+ Value: eth.DefaultConfig.Ethash.DatasetsInMem,
+ }
+ EthashDatasetsOnDiskFlag = cli.IntFlag{
+ Name: "ethash.dagsondisk",
+ Usage: "Number of recent ethash mining DAGs to keep on disk (1+GB each)",
+ Value: eth.DefaultConfig.Ethash.DatasetsOnDisk,
+ }
+ // Transaction pool settings
+ TxPoolLocalsFlag = cli.StringFlag{
+ Name: "txpool.locals",
+ Usage: "Comma separated accounts to treat as locals (no flush, priority inclusion)",
+ }
+ TxPoolNoLocalsFlag = cli.BoolFlag{
+ Name: "txpool.nolocals",
+ Usage: "Disables price exemptions for locally submitted transactions",
+ }
+ TxPoolJournalFlag = cli.StringFlag{
+ Name: "txpool.journal",
+ Usage: "Disk journal for local transaction to survive node restarts",
+ Value: core.DefaultTxPoolConfig.Journal,
+ }
+ TxPoolRejournalFlag = cli.DurationFlag{
+ Name: "txpool.rejournal",
+ Usage: "Time interval to regenerate the local transaction journal",
+ Value: core.DefaultTxPoolConfig.Rejournal,
+ }
+ TxPoolPriceLimitFlag = cli.Uint64Flag{
+ Name: "txpool.pricelimit",
+ Usage: "Minimum gas price limit to enforce for acceptance into the pool",
+ Value: eth.DefaultConfig.TxPool.PriceLimit,
+ }
+ TxPoolPriceBumpFlag = cli.Uint64Flag{
+ Name: "txpool.pricebump",
+ Usage: "Price bump percentage to replace an already existing transaction",
+ Value: eth.DefaultConfig.TxPool.PriceBump,
+ }
+ TxPoolAccountSlotsFlag = cli.Uint64Flag{
+ Name: "txpool.accountslots",
+ Usage: "Minimum number of executable transaction slots guaranteed per account",
+ Value: eth.DefaultConfig.TxPool.AccountSlots,
+ }
+ TxPoolGlobalSlotsFlag = cli.Uint64Flag{
+ Name: "txpool.globalslots",
+ Usage: "Maximum number of executable transaction slots for all accounts",
+ Value: eth.DefaultConfig.TxPool.GlobalSlots,
+ }
+ TxPoolAccountQueueFlag = cli.Uint64Flag{
+ Name: "txpool.accountqueue",
+ Usage: "Maximum number of non-executable transaction slots permitted per account",
+ Value: eth.DefaultConfig.TxPool.AccountQueue,
+ }
+ TxPoolGlobalQueueFlag = cli.Uint64Flag{
+ Name: "txpool.globalqueue",
+ Usage: "Maximum number of non-executable transaction slots for all accounts",
+ Value: eth.DefaultConfig.TxPool.GlobalQueue,
+ }
+ TxPoolLifetimeFlag = cli.DurationFlag{
+ Name: "txpool.lifetime",
+ Usage: "Maximum amount of time non-executable transaction are queued",
+ Value: eth.DefaultConfig.TxPool.Lifetime,
+ }
+ // Performance tuning settings
+ CacheFlag = cli.IntFlag{
+ Name: "cache",
+ Usage: "Megabytes of memory allocated to internal caching (default = 4096 mainnet full node, 128 light mode)",
+ Value: 1024,
+ }
+ CacheDatabaseFlag = cli.IntFlag{
+ Name: "cache.database",
+ Usage: "Percentage of cache memory allowance to use for database io",
+ Value: 50,
+ }
+ CacheTrieFlag = cli.IntFlag{
+ Name: "cache.trie",
+ Usage: "Percentage of cache memory allowance to use for trie caching (default = 25% full mode, 50% archive mode)",
+ Value: 25,
+ }
+ CacheGCFlag = cli.IntFlag{
+ Name: "cache.gc",
+ Usage: "Percentage of cache memory allowance to use for trie pruning (default = 25% full mode, 0% archive mode)",
+ Value: 25,
+ }
+ CacheNoPrefetchFlag = cli.BoolFlag{
+ Name: "cache.noprefetch",
+ Usage: "Disable heuristic state prefetch during block import (less CPU and disk IO, more time waiting for data)",
+ }
+ // Miner settings
+ MiningEnabledFlag = cli.BoolFlag{
+ Name: "mine",
+ Usage: "Enable mining",
+ }
+ MinerThreadsFlag = cli.IntFlag{
+ Name: "miner.threads",
+ Usage: "Number of CPU threads to use for mining",
+ Value: 0,
+ }
+ MinerLegacyThreadsFlag = cli.IntFlag{
+ Name: "minerthreads",
+ Usage: "Number of CPU threads to use for mining (deprecated, use --miner.threads)",
+ Value: 0,
+ }
+ MinerNotifyFlag = cli.StringFlag{
+ Name: "miner.notify",
+ Usage: "Comma separated HTTP URL list to notify of new work packages",
+ }
+ MinerGasTargetFlag = cli.Uint64Flag{
+ Name: "miner.gastarget",
+ Usage: "Target gas floor for mined blocks",
+ Value: eth.DefaultConfig.Miner.GasFloor,
+ }
+ MinerLegacyGasTargetFlag = cli.Uint64Flag{
+ Name: "targetgaslimit",
+ Usage: "Target gas floor for mined blocks (deprecated, use --miner.gastarget)",
+ Value: eth.DefaultConfig.Miner.GasFloor,
+ }
+ MinerGasLimitFlag = cli.Uint64Flag{
+ Name: "miner.gaslimit",
+ Usage: "Target gas ceiling for mined blocks",
+ Value: eth.DefaultConfig.Miner.GasCeil,
+ }
+ MinerGasPriceFlag = BigFlag{
+ Name: "miner.gasprice",
+ Usage: "Minimum gas price for mining a transaction",
+ Value: eth.DefaultConfig.Miner.GasPrice,
+ }
+ MinerLegacyGasPriceFlag = BigFlag{
+ Name: "gasprice",
+ Usage: "Minimum gas price for mining a transaction (deprecated, use --miner.gasprice)",
+ Value: eth.DefaultConfig.Miner.GasPrice,
+ }
+ MinerEtherbaseFlag = cli.StringFlag{
+ Name: "miner.etherbase",
+ Usage: "Public address for block mining rewards (default = first account)",
+ Value: "0",
+ }
+ MinerLegacyEtherbaseFlag = cli.StringFlag{
+ Name: "etherbase",
+ Usage: "Public address for block mining rewards (default = first account, deprecated, use --miner.etherbase)",
+ Value: "0",
+ }
+ MinerExtraDataFlag = cli.StringFlag{
+ Name: "miner.extradata",
+ Usage: "Block extra data set by the miner (default = client version)",
+ }
+ MinerLegacyExtraDataFlag = cli.StringFlag{
+ Name: "extradata",
+ Usage: "Block extra data set by the miner (default = client version, deprecated, use --miner.extradata)",
+ }
+ MinerRecommitIntervalFlag = cli.DurationFlag{
+ Name: "miner.recommit",
+ Usage: "Time interval to recreate the block being mined",
+ Value: eth.DefaultConfig.Miner.Recommit,
+ }
+ MinerNoVerfiyFlag = cli.BoolFlag{
+ Name: "miner.noverify",
+ Usage: "Disable remote sealing verification",
+ }
+ // Account settings
+ UnlockedAccountFlag = cli.StringFlag{
+ Name: "unlock",
+ Usage: "Comma separated list of accounts to unlock",
+ Value: "",
+ }
+ PasswordFileFlag = cli.StringFlag{
+ Name: "password",
+ Usage: "Password file to use for non-interactive password input",
+ Value: "",
+ }
+ ExternalSignerFlag = cli.StringFlag{
+ Name: "signer",
+ Usage: "External signer (url or path to ipc file)",
+ Value: "",
+ }
+ VMEnableDebugFlag = cli.BoolFlag{
+ Name: "vmdebug",
+ Usage: "Record information useful for VM and contract debugging",
+ }
+ InsecureUnlockAllowedFlag = cli.BoolFlag{
+ Name: "allow-insecure-unlock",
+ Usage: "Allow insecure account unlocking when account-related RPCs are exposed by http",
+ }
+ RPCGlobalGasCap = cli.Uint64Flag{
+ Name: "rpc.gascap",
+ Usage: "Sets a cap on gas that can be used in eth_call/estimateGas",
+ }
+ // Logging and debug settings
+ EthStatsURLFlag = cli.StringFlag{
+ Name: "ethstats",
+ Usage: "Reporting URL of a ethstats service (nodename:secret@host:port)",
+ }
+ FakePoWFlag = cli.BoolFlag{
+ Name: "fakepow",
+ Usage: "Disables proof-of-work verification",
+ }
+ NoCompactionFlag = cli.BoolFlag{
+ Name: "nocompaction",
+ Usage: "Disables db compaction after import",
+ }
+ // RPC settings
+ IPCDisabledFlag = cli.BoolFlag{
+ Name: "ipcdisable",
+ Usage: "Disable the IPC-RPC server",
+ }
+ IPCPathFlag = DirectoryFlag{
+ Name: "ipcpath",
+ Usage: "Filename for IPC socket/pipe within the datadir (explicit paths escape it)",
+ }
+ RPCEnabledFlag = cli.BoolFlag{
+ Name: "rpc",
+ Usage: "Enable the HTTP-RPC server",
+ }
+ RPCListenAddrFlag = cli.StringFlag{
+ Name: "rpcaddr",
+ Usage: "HTTP-RPC server listening interface",
+ Value: node.DefaultHTTPHost,
+ }
+ RPCPortFlag = cli.IntFlag{
+ Name: "rpcport",
+ Usage: "HTTP-RPC server listening port",
+ Value: node.DefaultHTTPPort,
+ }
+ RPCCORSDomainFlag = cli.StringFlag{
+ Name: "rpccorsdomain",
+ Usage: "Comma separated list of domains from which to accept cross origin requests (browser enforced)",
+ Value: "",
+ }
+ RPCVirtualHostsFlag = cli.StringFlag{
+ Name: "rpcvhosts",
+ Usage: "Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard.",
+ Value: strings.Join(node.DefaultConfig.HTTPVirtualHosts, ","),
+ }
+ RPCApiFlag = cli.StringFlag{
+ Name: "rpcapi",
+ Usage: "API's offered over the HTTP-RPC interface",
+ Value: "",
+ }
+ WSEnabledFlag = cli.BoolFlag{
+ Name: "ws",
+ Usage: "Enable the WS-RPC server",
+ }
+ WSListenAddrFlag = cli.StringFlag{
+ Name: "wsaddr",
+ Usage: "WS-RPC server listening interface",
+ Value: node.DefaultWSHost,
+ }
+ WSPortFlag = cli.IntFlag{
+ Name: "wsport",
+ Usage: "WS-RPC server listening port",
+ Value: node.DefaultWSPort,
+ }
+ WSApiFlag = cli.StringFlag{
+ Name: "wsapi",
+ Usage: "API's offered over the WS-RPC interface",
+ Value: "",
+ }
+ WSAllowedOriginsFlag = cli.StringFlag{
+ Name: "wsorigins",
+ Usage: "Origins from which to accept websockets requests",
+ Value: "",
+ }
+ GraphQLEnabledFlag = cli.BoolFlag{
+ Name: "graphql",
+ Usage: "Enable the GraphQL server",
+ }
+ GraphQLListenAddrFlag = cli.StringFlag{
+ Name: "graphql.addr",
+ Usage: "GraphQL server listening interface",
+ Value: node.DefaultGraphQLHost,
+ }
+ GraphQLPortFlag = cli.IntFlag{
+ Name: "graphql.port",
+ Usage: "GraphQL server listening port",
+ Value: node.DefaultGraphQLPort,
+ }
+ GraphQLCORSDomainFlag = cli.StringFlag{
+ Name: "graphql.corsdomain",
+ Usage: "Comma separated list of domains from which to accept cross origin requests (browser enforced)",
+ Value: "",
+ }
+ GraphQLVirtualHostsFlag = cli.StringFlag{
+ Name: "graphql.vhosts",
+ Usage: "Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard.",
+ Value: strings.Join(node.DefaultConfig.GraphQLVirtualHosts, ","),
+ }
+ ExecFlag = cli.StringFlag{
+ Name: "exec",
+ Usage: "Execute JavaScript statement",
+ }
+ PreloadJSFlag = cli.StringFlag{
+ Name: "preload",
+ Usage: "Comma separated list of JavaScript files to preload into the console",
+ }
+
+ // Network Settings
+ MaxPeersFlag = cli.IntFlag{
+ Name: "maxpeers",
+ Usage: "Maximum number of network peers (network disabled if set to 0)",
+ Value: node.DefaultConfig.P2P.MaxPeers,
+ }
+ MaxPendingPeersFlag = cli.IntFlag{
+ Name: "maxpendpeers",
+ Usage: "Maximum number of pending connection attempts (defaults used if set to 0)",
+ Value: node.DefaultConfig.P2P.MaxPendingPeers,
+ }
+ ListenPortFlag = cli.IntFlag{
+ Name: "port",
+ Usage: "Network listening port",
+ Value: 30303,
+ }
+ BootnodesFlag = cli.StringFlag{
+ Name: "bootnodes",
+ Usage: "Comma separated enode URLs for P2P discovery bootstrap (set v4+v5 instead for light servers)",
+ Value: "",
+ }
+ BootnodesV4Flag = cli.StringFlag{
+ Name: "bootnodesv4",
+ Usage: "Comma separated enode URLs for P2P v4 discovery bootstrap (light server, full nodes)",
+ Value: "",
+ }
+ BootnodesV5Flag = cli.StringFlag{
+ Name: "bootnodesv5",
+ Usage: "Comma separated enode URLs for P2P v5 discovery bootstrap (light server, light nodes)",
+ 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",
+ Usage: "NAT port mapping mechanism (any|none|upnp|pmp|extip:<IP>)",
+ Value: "any",
+ }
+ NoDiscoverFlag = cli.BoolFlag{
+ Name: "nodiscover",
+ Usage: "Disables the peer discovery mechanism (manual peer addition)",
+ }
+ DiscoveryV5Flag = cli.BoolFlag{
+ Name: "v5disc",
+ Usage: "Enables the experimental RLPx V5 (Topic Discovery) mechanism",
+ }
+ NetrestrictFlag = cli.StringFlag{
+ Name: "netrestrict",
+ Usage: "Restricts network communication to the given IP networks (CIDR masks)",
+ }
+
+ // ATM the url is left to the user and deployment to
+ JSpathFlag = cli.StringFlag{
+ Name: "jspath",
+ Usage: "JavaScript root path for `loadScript`",
+ Value: ".",
+ }
+
+ // Gas price oracle settings
+ GpoBlocksFlag = cli.IntFlag{
+ Name: "gpoblocks",
+ Usage: "Number of recent blocks to check for gas prices",
+ Value: eth.DefaultConfig.GPO.Blocks,
+ }
+ GpoPercentileFlag = cli.IntFlag{
+ Name: "gpopercentile",
+ Usage: "Suggested gas price is the given percentile of a set of recent transaction gas prices",
+ Value: eth.DefaultConfig.GPO.Percentile,
+ }
+ WhisperEnabledFlag = cli.BoolFlag{
+ Name: "shh",
+ Usage: "Enable Whisper",
+ }
+ WhisperMaxMessageSizeFlag = cli.IntFlag{
+ Name: "shh.maxmessagesize",
+ Usage: "Max message size accepted",
+ Value: int(whisper.DefaultMaxMessageSize),
+ }
+ WhisperMinPOWFlag = cli.Float64Flag{
+ Name: "shh.pow",
+ Usage: "Minimum POW accepted",
+ Value: whisper.DefaultMinimumPoW,
+ }
+ WhisperRestrictConnectionBetweenLightClientsFlag = cli.BoolFlag{
+ Name: "shh.restrict-light",
+ Usage: "Restrict connection between two whisper light clients",
+ }
+
+ // Metrics flags
+ MetricsEnabledFlag = cli.BoolFlag{
+ Name: "metrics",
+ Usage: "Enable metrics collection and reporting",
+ }
+ MetricsEnabledExpensiveFlag = cli.BoolFlag{
+ Name: "metrics.expensive",
+ Usage: "Enable expensive metrics collection and reporting",
+ }
+ MetricsEnableInfluxDBFlag = cli.BoolFlag{
+ Name: "metrics.influxdb",
+ Usage: "Enable metrics export/push to an external InfluxDB database",
+ }
+ MetricsInfluxDBEndpointFlag = cli.StringFlag{
+ Name: "metrics.influxdb.endpoint",
+ Usage: "InfluxDB API endpoint to report metrics to",
+ Value: "http://localhost:8086",
+ }
+ MetricsInfluxDBDatabaseFlag = cli.StringFlag{
+ Name: "metrics.influxdb.database",
+ Usage: "InfluxDB database name to push reported metrics to",
+ Value: "geth",
+ }
+ MetricsInfluxDBUsernameFlag = cli.StringFlag{
+ Name: "metrics.influxdb.username",
+ Usage: "Username to authorize access to the database",
+ Value: "test",
+ }
+ MetricsInfluxDBPasswordFlag = cli.StringFlag{
+ Name: "metrics.influxdb.password",
+ Usage: "Password to authorize access to the database",
+ Value: "test",
+ }
+ // Tags are part of every measurement sent to InfluxDB. Queries on tags are faster in InfluxDB.
+ // For example `host` tag could be used so that we can group all nodes and average a measurement
+ // across all of them, but also so that we can select a specific node and inspect its measurements.
+ // https://docs.influxdata.com/influxdb/v1.4/concepts/key_concepts/#tag-key
+ MetricsInfluxDBTagsFlag = cli.StringFlag{
+ Name: "metrics.influxdb.tags",
+ Usage: "Comma-separated InfluxDB tags (key/values) attached to all measurements",
+ Value: "host=localhost",
+ }
+
+ EWASMInterpreterFlag = cli.StringFlag{
+ Name: "vm.ewasm",
+ Usage: "External ewasm configuration (default = built-in interpreter)",
+ Value: "",
+ }
+ EVMInterpreterFlag = cli.StringFlag{
+ Name: "vm.evm",
+ Usage: "External EVM configuration (default = built-in interpreter)",
+ Value: "",
+ }
+)
+
+// MakeDataDir retrieves the currently requested data directory, terminating
+// 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.
+func MakeDataDir(ctx *cli.Context) string {
+ if path := ctx.GlobalString(DataDirFlag.Name); path != "" {
+ if ctx.GlobalBool(TestnetFlag.Name) {
+ return filepath.Join(path, "testnet")
+ }
+ if ctx.GlobalBool(RinkebyFlag.Name) {
+ return filepath.Join(path, "rinkeby")
+ }
+ if ctx.GlobalBool(GoerliFlag.Name) {
+ return filepath.Join(path, "goerli")
+ }
+ return path
+ }
+ Fatalf("Cannot determine default data directory, please set manually (--datadir)")
+ return ""
+}
+
+// setNodeKey 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 setNodeKey(ctx *cli.Context, cfg *p2p.Config) {
+ var (
+ hex = ctx.GlobalString(NodeKeyHexFlag.Name)
+ file = ctx.GlobalString(NodeKeyFileFlag.Name)
+ key *ecdsa.PrivateKey
+ 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)
+ }
+ cfg.PrivateKey = key
+ case hex != "":
+ if key, err = crypto.HexToECDSA(hex); err != nil {
+ Fatalf("Option %q: %v", NodeKeyHexFlag.Name, err)
+ }
+ cfg.PrivateKey = key
+ }
+}
+
+// setNodeUserIdent creates the user identifier from CLI flags.
+func setNodeUserIdent(ctx *cli.Context, cfg *node.Config) {
+ if identity := ctx.GlobalString(IdentityFlag.Name); len(identity) > 0 {
+ cfg.UserIdent = identity
+ }
+}
+
+// setBootstrapNodes creates a list of bootstrap nodes from the command line
+// flags, reverting to pre-configured ones if none have been specified.
+func setBootstrapNodes(ctx *cli.Context, cfg *p2p.Config) {
+ urls := params.MainnetBootnodes
+ switch {
+ case ctx.GlobalIsSet(BootnodesFlag.Name) || ctx.GlobalIsSet(BootnodesV4Flag.Name):
+ if ctx.GlobalIsSet(BootnodesV4Flag.Name) {
+ urls = strings.Split(ctx.GlobalString(BootnodesV4Flag.Name), ",")
+ } else {
+ urls = strings.Split(ctx.GlobalString(BootnodesFlag.Name), ",")
+ }
+ case ctx.GlobalBool(TestnetFlag.Name):
+ urls = params.TestnetBootnodes
+ case ctx.GlobalBool(RinkebyFlag.Name):
+ urls = params.RinkebyBootnodes
+ case ctx.GlobalBool(GoerliFlag.Name):
+ urls = params.GoerliBootnodes
+ case cfg.BootstrapNodes != nil:
+ return // already set, don't apply defaults.
+ }
+
+ cfg.BootstrapNodes = make([]*enode.Node, 0, len(urls))
+ for _, url := range urls {
+ if url != "" {
+ node, err := enode.Parse(enode.ValidSchemes, url)
+ if err != nil {
+ log.Crit("Bootstrap URL invalid", "enode", url, "err", err)
+ continue
+ }
+ cfg.BootstrapNodes = append(cfg.BootstrapNodes, node)
+ }
+ }
+}
+
+// setBootstrapNodesV5 creates a list of bootstrap nodes from the command line
+// flags, reverting to pre-configured ones if none have been specified.
+func setBootstrapNodesV5(ctx *cli.Context, cfg *p2p.Config) {
+ urls := params.DiscoveryV5Bootnodes
+ switch {
+ case ctx.GlobalIsSet(BootnodesFlag.Name) || ctx.GlobalIsSet(BootnodesV5Flag.Name):
+ if ctx.GlobalIsSet(BootnodesV5Flag.Name) {
+ urls = strings.Split(ctx.GlobalString(BootnodesV5Flag.Name), ",")
+ } else {
+ urls = strings.Split(ctx.GlobalString(BootnodesFlag.Name), ",")
+ }
+ case ctx.GlobalBool(RinkebyFlag.Name):
+ urls = params.RinkebyBootnodes
+ case ctx.GlobalBool(GoerliFlag.Name):
+ urls = params.GoerliBootnodes
+ case cfg.BootstrapNodesV5 != nil:
+ return // already set, don't apply defaults.
+ }
+
+ cfg.BootstrapNodesV5 = make([]*discv5.Node, 0, len(urls))
+ for _, url := range urls {
+ if url != "" {
+ node, err := discv5.ParseNode(url)
+ if err != nil {
+ log.Error("Bootstrap URL invalid", "enode", url, "err", err)
+ continue
+ }
+ cfg.BootstrapNodesV5 = append(cfg.BootstrapNodesV5, node)
+ }
+ }
+}
+
+// setListenAddress creates a TCP listening address string from set command
+// line flags.
+func setListenAddress(ctx *cli.Context, cfg *p2p.Config) {
+ if ctx.GlobalIsSet(ListenPortFlag.Name) {
+ cfg.ListenAddr = fmt.Sprintf(":%d", ctx.GlobalInt(ListenPortFlag.Name))
+ }
+}
+
+// setNAT creates a port mapper from command line flags.
+func setNAT(ctx *cli.Context, cfg *p2p.Config) {
+ if ctx.GlobalIsSet(NATFlag.Name) {
+ natif, err := nat.Parse(ctx.GlobalString(NATFlag.Name))
+ if err != nil {
+ Fatalf("Option %s: %v", NATFlag.Name, err)
+ }
+ cfg.NAT = natif
+ }
+}
+
+// splitAndTrim splits input separated by a comma
+// and trims excessive white space from the substrings.
+func splitAndTrim(input string) []string {
+ result := strings.Split(input, ",")
+ for i, r := range result {
+ result[i] = strings.TrimSpace(r)
+ }
+ return result
+}
+
+// setHTTP creates the HTTP RPC listener interface string from the set
+// command line flags, returning empty if the HTTP endpoint is disabled.
+func setHTTP(ctx *cli.Context, cfg *node.Config) {
+ if ctx.GlobalBool(RPCEnabledFlag.Name) && cfg.HTTPHost == "" {
+ cfg.HTTPHost = "127.0.0.1"
+ if ctx.GlobalIsSet(RPCListenAddrFlag.Name) {
+ cfg.HTTPHost = ctx.GlobalString(RPCListenAddrFlag.Name)
+ }
+ }
+ if ctx.GlobalIsSet(RPCPortFlag.Name) {
+ cfg.HTTPPort = ctx.GlobalInt(RPCPortFlag.Name)
+ }
+ if ctx.GlobalIsSet(RPCCORSDomainFlag.Name) {
+ cfg.HTTPCors = splitAndTrim(ctx.GlobalString(RPCCORSDomainFlag.Name))
+ }
+ if ctx.GlobalIsSet(RPCApiFlag.Name) {
+ cfg.HTTPModules = splitAndTrim(ctx.GlobalString(RPCApiFlag.Name))
+ }
+ if ctx.GlobalIsSet(RPCVirtualHostsFlag.Name) {
+ cfg.HTTPVirtualHosts = splitAndTrim(ctx.GlobalString(RPCVirtualHostsFlag.Name))
+ }
+}
+
+// setGraphQL creates the GraphQL listener interface string from the set
+// command line flags, returning empty if the GraphQL endpoint is disabled.
+func setGraphQL(ctx *cli.Context, cfg *node.Config) {
+ if ctx.GlobalBool(GraphQLEnabledFlag.Name) && cfg.GraphQLHost == "" {
+ cfg.GraphQLHost = "127.0.0.1"
+ if ctx.GlobalIsSet(GraphQLListenAddrFlag.Name) {
+ cfg.GraphQLHost = ctx.GlobalString(GraphQLListenAddrFlag.Name)
+ }
+ }
+ cfg.GraphQLPort = ctx.GlobalInt(GraphQLPortFlag.Name)
+ if ctx.GlobalIsSet(GraphQLCORSDomainFlag.Name) {
+ cfg.GraphQLCors = splitAndTrim(ctx.GlobalString(GraphQLCORSDomainFlag.Name))
+ }
+ if ctx.GlobalIsSet(GraphQLVirtualHostsFlag.Name) {
+ cfg.GraphQLVirtualHosts = splitAndTrim(ctx.GlobalString(GraphQLVirtualHostsFlag.Name))
+ }
+}
+
+// setWS creates the WebSocket RPC listener interface string from the set
+// command line flags, returning empty if the HTTP endpoint is disabled.
+func setWS(ctx *cli.Context, cfg *node.Config) {
+ if ctx.GlobalBool(WSEnabledFlag.Name) && cfg.WSHost == "" {
+ cfg.WSHost = "127.0.0.1"
+ if ctx.GlobalIsSet(WSListenAddrFlag.Name) {
+ cfg.WSHost = ctx.GlobalString(WSListenAddrFlag.Name)
+ }
+ }
+ if ctx.GlobalIsSet(WSPortFlag.Name) {
+ cfg.WSPort = ctx.GlobalInt(WSPortFlag.Name)
+ }
+ if ctx.GlobalIsSet(WSAllowedOriginsFlag.Name) {
+ cfg.WSOrigins = splitAndTrim(ctx.GlobalString(WSAllowedOriginsFlag.Name))
+ }
+ if ctx.GlobalIsSet(WSApiFlag.Name) {
+ cfg.WSModules = splitAndTrim(ctx.GlobalString(WSApiFlag.Name))
+ }
+}
+
+// setIPC creates an IPC path configuration from the set command line flags,
+// returning an empty string if IPC was explicitly disabled, or the set path.
+func setIPC(ctx *cli.Context, cfg *node.Config) {
+ CheckExclusive(ctx, IPCDisabledFlag, IPCPathFlag)
+ switch {
+ case ctx.GlobalBool(IPCDisabledFlag.Name):
+ cfg.IPCPath = ""
+ case ctx.GlobalIsSet(IPCPathFlag.Name):
+ cfg.IPCPath = ctx.GlobalString(IPCPathFlag.Name)
+ }
+}
+
+// setLes configures the les server and ultra light client settings from the command line flags.
+func setLes(ctx *cli.Context, cfg *eth.Config) {
+ if ctx.GlobalIsSet(LightLegacyServFlag.Name) {
+ cfg.LightServ = ctx.GlobalInt(LightLegacyServFlag.Name)
+ }
+ if ctx.GlobalIsSet(LightServeFlag.Name) {
+ cfg.LightServ = ctx.GlobalInt(LightServeFlag.Name)
+ }
+ if ctx.GlobalIsSet(LightIngressFlag.Name) {
+ cfg.LightIngress = ctx.GlobalInt(LightIngressFlag.Name)
+ }
+ if ctx.GlobalIsSet(LightEgressFlag.Name) {
+ cfg.LightEgress = ctx.GlobalInt(LightEgressFlag.Name)
+ }
+ if ctx.GlobalIsSet(LightLegacyPeersFlag.Name) {
+ cfg.LightPeers = ctx.GlobalInt(LightLegacyPeersFlag.Name)
+ }
+ if ctx.GlobalIsSet(LightMaxPeersFlag.Name) {
+ cfg.LightPeers = ctx.GlobalInt(LightMaxPeersFlag.Name)
+ }
+ if ctx.GlobalIsSet(UltraLightServersFlag.Name) {
+ cfg.UltraLightServers = strings.Split(ctx.GlobalString(UltraLightServersFlag.Name), ",")
+ }
+ if ctx.GlobalIsSet(UltraLightFractionFlag.Name) {
+ cfg.UltraLightFraction = ctx.GlobalInt(UltraLightFractionFlag.Name)
+ }
+ if cfg.UltraLightFraction <= 0 && cfg.UltraLightFraction > 100 {
+ log.Error("Ultra light fraction is invalid", "had", cfg.UltraLightFraction, "updated", eth.DefaultConfig.UltraLightFraction)
+ cfg.UltraLightFraction = eth.DefaultConfig.UltraLightFraction
+ }
+ if ctx.GlobalIsSet(UltraLightOnlyAnnounceFlag.Name) {
+ cfg.UltraLightOnlyAnnounce = ctx.GlobalBool(UltraLightOnlyAnnounceFlag.Name)
+ }
+}
+
+// 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 {
+ limit, err := fdlimit.Maximum()
+ if err != nil {
+ Fatalf("Failed to retrieve file descriptor allowance: %v", err)
+ }
+ raised, err := fdlimit.Raise(uint64(limit))
+ if err != nil {
+ Fatalf("Failed to raise file descriptor allowance: %v", err)
+ }
+ return int(raised / 2) // Leave half for netwo