Documentation

Overview

    Package utils contains internal helper functions for go-ethereum commands.

    Package utils contains internal helper functions for go-ethereum commands.

    Package utils contains internal helper functions for go-ethereum commands.

    Index

    Constants

    This section is empty.

    Variables

    View Source
    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)",
    	}
    	MinFreeDiskSpaceFlag = DirectoryFlag{
    		Name:  "datadir.minfreedisk",
    		Usage: "Minimum free disk space in MB, once reached triggers auto shut down (default = --cache.gc converted to MB, 0 = disabled)",
    	}
    	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 (deprecated)",
    	}
    	USBFlag = cli.BoolFlag{
    		Name:  "usb",
    		Usage: "Enable monitoring and management of 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: "Explicitly set network id (integer)(For testnets: use --ropsten, --rinkeby, --goerli instead)",
    		Value: ethconfig.Defaults.NetworkId,
    	}
    	MainnetFlag = cli.BoolFlag{
    		Name:  "mainnet",
    		Usage: "Ethereum mainnet",
    	}
    	GoerliFlag = cli.BoolFlag{
    		Name:  "goerli",
    		Usage: "Görli network: pre-configured proof-of-authority test network",
    	}
    	YoloV3Flag = cli.BoolFlag{
    		Name:  "yolov3",
    		Usage: "YOLOv3 network: pre-configured proof-of-authority shortlived test network.",
    	}
    	RinkebyFlag = cli.BoolFlag{
    		Name:  "rinkeby",
    		Usage: "Rinkeby network: pre-configured proof-of-authority test network",
    	}
    	RopstenFlag = cli.BoolFlag{
    		Name:  "ropsten",
    		Usage: "Ropsten network: pre-configured proof-of-work 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)",
    	}
    
    	SyncModeFlag = TextMarshalerFlag{
    		Name:  "syncmode",
    		Usage: `Blockchain sync mode ("fast", "full", "snap" or "light")`,
    		Value: &defaultSyncMode,
    	}
    	GCModeFlag = cli.StringFlag{
    		Name:  "gcmode",
    		Usage: `Blockchain garbage collection mode ("full", "archive")`,
    		Value: "full",
    	}
    	SnapshotFlag = cli.BoolTFlag{
    		Name:  "snapshot",
    		Usage: `Enables snapshot-database mode (default = enable)`,
    	}
    	TxLookupLimitFlag = cli.Uint64Flag{
    		Name:  "txlookuplimit",
    		Usage: "Number of recent blocks to maintain transactions index for (default = about one year, 0 = entire chain)",
    		Value: ethconfig.Defaults.TxLookupLimit,
    	}
    	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>)",
    	}
    	BloomFilterSizeFlag = cli.Uint64Flag{
    		Name:  "bloomfilter.size",
    		Usage: "Megabytes of memory allocated to bloom-filter for pruning",
    		Value: 2048,
    	}
    	OverrideBerlinFlag = cli.Uint64Flag{
    		Name:  "override.berlin",
    		Usage: "Manually specify Berlin fork-block, overriding the bundled setting",
    	}
    	// Light server and client settings
    	LightServeFlag = cli.IntFlag{
    		Name:  "light.serve",
    		Usage: "Maximum percentage of time allowed for serving LES requests (multi-threaded processing allows values over 100)",
    		Value: ethconfig.Defaults.LightServ,
    	}
    	LightIngressFlag = cli.IntFlag{
    		Name:  "light.ingress",
    		Usage: "Incoming bandwidth limit for serving light clients (kilobytes/sec, 0 = unlimited)",
    		Value: ethconfig.Defaults.LightIngress,
    	}
    	LightEgressFlag = cli.IntFlag{
    		Name:  "light.egress",
    		Usage: "Outgoing bandwidth limit for serving light clients (kilobytes/sec, 0 = unlimited)",
    		Value: ethconfig.Defaults.LightEgress,
    	}
    	LightMaxPeersFlag = cli.IntFlag{
    		Name:  "light.maxpeers",
    		Usage: "Maximum number of light clients to serve, or light servers to attach to",
    		Value: ethconfig.Defaults.LightPeers,
    	}
    	UltraLightServersFlag = cli.StringFlag{
    		Name:  "ulc.servers",
    		Usage: "List of trusted ultra-light servers",
    		Value: strings.Join(ethconfig.Defaults.UltraLightServers, ","),
    	}
    	UltraLightFractionFlag = cli.IntFlag{
    		Name:  "ulc.fraction",
    		Usage: "Minimum % of trusted ultra-light servers required to announce a new head",
    		Value: ethconfig.Defaults.UltraLightFraction,
    	}
    	UltraLightOnlyAnnounceFlag = cli.BoolFlag{
    		Name:  "ulc.onlyannounce",
    		Usage: "Ultra light server sends announcements only",
    	}
    	LightNoPruneFlag = cli.BoolFlag{
    		Name:  "light.nopruning",
    		Usage: "Disable ancient light chain data pruning",
    	}
    	LightNoSyncServeFlag = cli.BoolFlag{
    		Name:  "light.nosyncserve",
    		Usage: "Enables serving light clients before syncing",
    	}
    	// 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: ethconfig.Defaults.Ethash.CachesInMem,
    	}
    	EthashCachesOnDiskFlag = cli.IntFlag{
    		Name:  "ethash.cachesondisk",
    		Usage: "Number of recent ethash caches to keep on disk (16MB each)",
    		Value: ethconfig.Defaults.Ethash.CachesOnDisk,
    	}
    	EthashCachesLockMmapFlag = cli.BoolFlag{
    		Name:  "ethash.cacheslockmmap",
    		Usage: "Lock memory maps of recent ethash caches",
    	}
    	EthashDatasetDirFlag = DirectoryFlag{
    		Name:  "ethash.dagdir",
    		Usage: "Directory to store the ethash mining DAGs",
    		Value: DirectoryString(ethconfig.Defaults.Ethash.DatasetDir),
    	}
    	EthashDatasetsInMemoryFlag = cli.IntFlag{
    		Name:  "ethash.dagsinmem",
    		Usage: "Number of recent ethash mining DAGs to keep in memory (1+GB each)",
    		Value: ethconfig.Defaults.Ethash.DatasetsInMem,
    	}
    	EthashDatasetsOnDiskFlag = cli.IntFlag{
    		Name:  "ethash.dagsondisk",
    		Usage: "Number of recent ethash mining DAGs to keep on disk (1+GB each)",
    		Value: ethconfig.Defaults.Ethash.DatasetsOnDisk,
    	}
    	EthashDatasetsLockMmapFlag = cli.BoolFlag{
    		Name:  "ethash.dagslockmmap",
    		Usage: "Lock memory maps for recent ethash mining DAGs",
    	}
    	// 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: ethconfig.Defaults.TxPool.PriceLimit,
    	}
    	TxPoolPriceBumpFlag = cli.Uint64Flag{
    		Name:  "txpool.pricebump",
    		Usage: "Price bump percentage to replace an already existing transaction",
    		Value: ethconfig.Defaults.TxPool.PriceBump,
    	}
    	TxPoolAccountSlotsFlag = cli.Uint64Flag{
    		Name:  "txpool.accountslots",
    		Usage: "Minimum number of executable transaction slots guaranteed per account",
    		Value: ethconfig.Defaults.TxPool.AccountSlots,
    	}
    	TxPoolGlobalSlotsFlag = cli.Uint64Flag{
    		Name:  "txpool.globalslots",
    		Usage: "Maximum number of executable transaction slots for all accounts",
    		Value: ethconfig.Defaults.TxPool.GlobalSlots,
    	}
    	TxPoolAccountQueueFlag = cli.Uint64Flag{
    		Name:  "txpool.accountqueue",
    		Usage: "Maximum number of non-executable transaction slots permitted per account",
    		Value: ethconfig.Defaults.TxPool.AccountQueue,
    	}
    	TxPoolGlobalQueueFlag = cli.Uint64Flag{
    		Name:  "txpool.globalqueue",
    		Usage: "Maximum number of non-executable transaction slots for all accounts",
    		Value: ethconfig.Defaults.TxPool.GlobalQueue,
    	}
    	TxPoolLifetimeFlag = cli.DurationFlag{
    		Name:  "txpool.lifetime",
    		Usage: "Maximum amount of time non-executable transaction are queued",
    		Value: ethconfig.Defaults.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 = 15% full mode, 30% archive mode)",
    		Value: 15,
    	}
    	CacheTrieJournalFlag = cli.StringFlag{
    		Name:  "cache.trie.journal",
    		Usage: "Disk journal directory for trie cache to survive node restarts",
    		Value: ethconfig.Defaults.TrieCleanCacheJournal,
    	}
    	CacheTrieRejournalFlag = cli.DurationFlag{
    		Name:  "cache.trie.rejournal",
    		Usage: "Time interval to regenerate the trie cache journal",
    		Value: ethconfig.Defaults.TrieCleanCacheRejournal,
    	}
    	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,
    	}
    	CacheSnapshotFlag = cli.IntFlag{
    		Name:  "cache.snapshot",
    		Usage: "Percentage of cache memory allowance to use for snapshot caching (default = 10% full mode, 20% archive mode)",
    		Value: 10,
    	}
    	CacheNoPrefetchFlag = cli.BoolFlag{
    		Name:  "cache.noprefetch",
    		Usage: "Disable heuristic state prefetch during block import (less CPU and disk IO, more time waiting for data)",
    	}
    	CachePreimagesFlag = cli.BoolFlag{
    		Name:  "cache.preimages",
    		Usage: "Enable recording the SHA3/keccak preimages of trie keys",
    	}
    	// 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,
    	}
    	MinerNotifyFlag = cli.StringFlag{
    		Name:  "miner.notify",
    		Usage: "Comma separated HTTP URL list to notify of new work packages",
    	}
    	MinerNotifyFullFlag = cli.BoolFlag{
    		Name:  "miner.notify.full",
    		Usage: "Notify with pending block headers instead of work packages",
    	}
    	MinerGasTargetFlag = cli.Uint64Flag{
    		Name:  "miner.gastarget",
    		Usage: "Target gas floor for mined blocks",
    		Value: ethconfig.Defaults.Miner.GasFloor,
    	}
    	MinerGasLimitFlag = cli.Uint64Flag{
    		Name:  "miner.gaslimit",
    		Usage: "Target gas ceiling for mined blocks",
    		Value: ethconfig.Defaults.Miner.GasCeil,
    	}
    	MinerGasPriceFlag = BigFlag{
    		Name:  "miner.gasprice",
    		Usage: "Minimum gas price for mining a transaction",
    		Value: ethconfig.Defaults.Miner.GasPrice,
    	}
    	MinerEtherbaseFlag = cli.StringFlag{
    		Name:  "miner.etherbase",
    		Usage: "Public address for block mining rewards (default = first account)",
    		Value: "0",
    	}
    	MinerExtraDataFlag = cli.StringFlag{
    		Name:  "miner.extradata",
    		Usage: "Block extra data set by the miner (default = client version)",
    	}
    	MinerRecommitIntervalFlag = cli.DurationFlag{
    		Name:  "miner.recommit",
    		Usage: "Time interval to recreate the block being mined",
    		Value: ethconfig.Defaults.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",
    	}
    	RPCGlobalGasCapFlag = cli.Uint64Flag{
    		Name:  "rpc.gascap",
    		Usage: "Sets a cap on gas that can be used in eth_call/estimateGas (0=infinite)",
    		Value: ethconfig.Defaults.RPCGasCap,
    	}
    	RPCGlobalTxFeeCapFlag = cli.Float64Flag{
    		Name:  "rpc.txfeecap",
    		Usage: "Sets a cap on transaction fee (in ether) that can be sent via the RPC APIs (0 = no cap)",
    		Value: ethconfig.Defaults.RPCTxFeeCap,
    	}
    	// 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)",
    	}
    	HTTPEnabledFlag = cli.BoolFlag{
    		Name:  "http",
    		Usage: "Enable the HTTP-RPC server",
    	}
    	HTTPListenAddrFlag = cli.StringFlag{
    		Name:  "http.addr",
    		Usage: "HTTP-RPC server listening interface",
    		Value: node.DefaultHTTPHost,
    	}
    	HTTPPortFlag = cli.IntFlag{
    		Name:  "http.port",
    		Usage: "HTTP-RPC server listening port",
    		Value: node.DefaultHTTPPort,
    	}
    	HTTPCORSDomainFlag = cli.StringFlag{
    		Name:  "http.corsdomain",
    		Usage: "Comma separated list of domains from which to accept cross origin requests (browser enforced)",
    		Value: "",
    	}
    	HTTPVirtualHostsFlag = cli.StringFlag{
    		Name:  "http.vhosts",
    		Usage: "Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard.",
    		Value: strings.Join(node.DefaultConfig.HTTPVirtualHosts, ","),
    	}
    	HTTPApiFlag = cli.StringFlag{
    		Name:  "http.api",
    		Usage: "API's offered over the HTTP-RPC interface",
    		Value: "",
    	}
    	HTTPPathPrefixFlag = cli.StringFlag{
    		Name:  "http.rpcprefix",
    		Usage: "HTTP path path prefix on which JSON-RPC is served. Use '/' to serve on all paths.",
    		Value: "",
    	}
    	GraphQLEnabledFlag = cli.BoolFlag{
    		Name:  "graphql",
    		Usage: "Enable GraphQL on the HTTP-RPC server. Note that GraphQL can only be started if an HTTP server is started as well.",
    	}
    	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, ","),
    	}
    	WSEnabledFlag = cli.BoolFlag{
    		Name:  "ws",
    		Usage: "Enable the WS-RPC server",
    	}
    	WSListenAddrFlag = cli.StringFlag{
    		Name:  "ws.addr",
    		Usage: "WS-RPC server listening interface",
    		Value: node.DefaultWSHost,
    	}
    	WSPortFlag = cli.IntFlag{
    		Name:  "ws.port",
    		Usage: "WS-RPC server listening port",
    		Value: node.DefaultWSPort,
    	}
    	WSApiFlag = cli.StringFlag{
    		Name:  "ws.api",
    		Usage: "API's offered over the WS-RPC interface",
    		Value: "",
    	}
    	WSAllowedOriginsFlag = cli.StringFlag{
    		Name:  "ws.origins",
    		Usage: "Origins from which to accept websockets requests",
    		Value: "",
    	}
    	WSPathPrefixFlag = cli.StringFlag{
    		Name:  "ws.rpcprefix",
    		Usage: "HTTP path prefix on which JSON-RPC is served. Use '/' to serve on all paths.",
    		Value: "",
    	}
    	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",
    	}
    	AllowUnprotectedTxs = cli.BoolFlag{
    		Name:  "rpc.allow-unprotected-txs",
    		Usage: "Allow for unprotected (non EIP155 signed) transactions to be submitted via RPC",
    	}
    
    	// 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",
    		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)",
    	}
    	DNSDiscoveryFlag = cli.StringFlag{
    		Name:  "discovery.dns",
    		Usage: "Sets DNS discovery entry points (use \"\" to disable DNS)",
    	}
    
    	// 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:  "gpo.blocks",
    		Usage: "Number of recent blocks to check for gas prices",
    		Value: ethconfig.Defaults.GPO.Blocks,
    	}
    	GpoPercentileFlag = cli.IntFlag{
    		Name:  "gpo.percentile",
    		Usage: "Suggested gas price is the given percentile of a set of recent transaction gas prices",
    		Value: ethconfig.Defaults.GPO.Percentile,
    	}
    	GpoMaxGasPriceFlag = cli.Int64Flag{
    		Name:  "gpo.maxprice",
    		Usage: "Maximum gas price will be recommended by gpo",
    		Value: ethconfig.Defaults.GPO.MaxPrice.Int64(),
    	}
    
    	// 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",
    	}
    
    	// MetricsHTTPFlag defines the endpoint for a stand-alone metrics HTTP endpoint.
    	// Since the pprof service enables sensitive/vulnerable behavior, this allows a user
    	// to enable a public-OK metrics endpoint without having to worry about ALSO exposing
    	// other profiling behavior or information.
    	MetricsHTTPFlag = cli.StringFlag{
    		Name:  "metrics.addr",
    		Usage: "Enable stand-alone metrics HTTP server listening interface",
    		Value: metrics.DefaultConfig.HTTP,
    	}
    	MetricsPortFlag = cli.IntFlag{
    		Name:  "metrics.port",
    		Usage: "Metrics HTTP server listening port",
    		Value: metrics.DefaultConfig.Port,
    	}
    	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: metrics.DefaultConfig.InfluxDBEndpoint,
    	}
    	MetricsInfluxDBDatabaseFlag = cli.StringFlag{
    		Name:  "metrics.influxdb.database",
    		Usage: "InfluxDB database name to push reported metrics to",
    		Value: metrics.DefaultConfig.InfluxDBDatabase,
    	}
    	MetricsInfluxDBUsernameFlag = cli.StringFlag{
    		Name:  "metrics.influxdb.username",
    		Usage: "Username to authorize access to the database",
    		Value: metrics.DefaultConfig.InfluxDBUsername,
    	}
    	MetricsInfluxDBPasswordFlag = cli.StringFlag{
    		Name:  "metrics.influxdb.password",
    		Usage: "Password to authorize access to the database",
    		Value: metrics.DefaultConfig.InfluxDBPassword,
    	}
    	// 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: metrics.DefaultConfig.InfluxDBTags,
    	}
    	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: "",
    	}
    )
    View Source
    var (
    	// (Deprecated May 2020, shown in aliased flags section)
    	LegacyRPCEnabledFlag = cli.BoolFlag{
    		Name:  "rpc",
    		Usage: "Enable the HTTP-RPC server (deprecated and will be removed June 2021, use --http)",
    	}
    	LegacyRPCListenAddrFlag = cli.StringFlag{
    		Name:  "rpcaddr",
    		Usage: "HTTP-RPC server listening interface (deprecated and will be removed June 2021, use --http.addr)",
    		Value: node.DefaultHTTPHost,
    	}
    	LegacyRPCPortFlag = cli.IntFlag{
    		Name:  "rpcport",
    		Usage: "HTTP-RPC server listening port (deprecated and will be removed June 2021, use --http.port)",
    		Value: node.DefaultHTTPPort,
    	}
    	LegacyRPCCORSDomainFlag = cli.StringFlag{
    		Name:  "rpccorsdomain",
    		Usage: "Comma separated list of domains from which to accept cross origin requests (browser enforced) (deprecated and will be removed June 2021, use --http.corsdomain)",
    		Value: "",
    	}
    	LegacyRPCVirtualHostsFlag = cli.StringFlag{
    		Name:  "rpcvhosts",
    		Usage: "Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard. (deprecated and will be removed June 2021, use --http.vhosts)",
    		Value: strings.Join(node.DefaultConfig.HTTPVirtualHosts, ","),
    	}
    	LegacyRPCApiFlag = cli.StringFlag{
    		Name:  "rpcapi",
    		Usage: "API's offered over the HTTP-RPC interface (deprecated and will be removed June 2021, use --http.api)",
    		Value: "",
    	}
    )
    View Source
    var DeprecatedFlags = []cli.Flag{}
    View Source
    var ShowDeprecated = cli.Command{
    	Action:      showDeprecated,
    	Name:        "show-deprecated-flags",
    	Usage:       "Show flags that have been deprecated",
    	ArgsUsage:   " ",
    	Category:    "MISCELLANEOUS COMMANDS",
    	Description: "Show flags that have been deprecated and will soon be removed",
    }

    Functions

    func CheckExclusive

    func CheckExclusive(ctx *cli.Context, args ...interface{})

      CheckExclusive verifies that only a single instance of the provided flags was set by the user. Each flag might optionally be followed by a string type to specialize it further.

      func ExportAppendChain

      func ExportAppendChain(blockchain *core.BlockChain, fn string, first uint64, last uint64) error

        ExportAppendChain exports a blockchain into the specified file, appending to the file if data already exists in it.

        func ExportChain

        func ExportChain(blockchain *core.BlockChain, fn string) error

          ExportChain exports a blockchain into the specified file, truncating any data already present in the file.

          func ExportPreimages

          func ExportPreimages(db ethdb.Database, fn string) error

            ExportPreimages exports all known hash preimages into the specified file, truncating any data already present in the file.

            func Fatalf

            func Fatalf(format string, args ...interface{})

              Fatalf formats a message to standard error and exits the program. The message is also printed to standard output if standard error is redirected to a different file.

              func GetPassPhrase

              func GetPassPhrase(text string, confirmation bool) string

                GetPassPhrase displays the given text(prompt) to the user and requests some textual data to be entered, but one which must not be echoed out into the terminal. The method returns the input provided by the user.

                func GetPassPhraseWithList

                func GetPassPhraseWithList(text string, confirmation bool, index int, passwords []string) string

                  GetPassPhraseWithList retrieves the password associated with an account, either fetched from a list of preloaded passphrases, or requested interactively from the user.

                  func GlobalBig

                  func GlobalBig(ctx *cli.Context, name string) *big.Int

                    GlobalBig returns the value of a BigFlag from the global flag set.

                    func HomeDir

                    func HomeDir() string

                    func ImportChain

                    func ImportChain(chain *core.BlockChain, fn string) error

                    func ImportPreimages

                    func ImportPreimages(db ethdb.Database, fn string) error

                      ImportPreimages imports a batch of exported hash preimages into the database.

                      func MakeAddress

                      func MakeAddress(ks *keystore.KeyStore, account string) (accounts.Account, error)

                        MakeAddress converts an account specified directly as a hex encoded string or a key index in the key store to an internal account representation.

                        func MakeChain

                        func MakeChain(ctx *cli.Context, stack *node.Node) (chain *core.BlockChain, chainDb ethdb.Database)

                          MakeChain creates a chain manager from set command line flags.

                          func MakeChainDatabase

                          func MakeChainDatabase(ctx *cli.Context, stack *node.Node, readonly bool) ethdb.Database

                            MakeChainDatabase open an LevelDB using the flags passed to the client and will hard crash if it fails.

                            func MakeConsolePreloads

                            func MakeConsolePreloads(ctx *cli.Context) []string

                              MakeConsolePreloads retrieves the absolute paths for the console JavaScript scripts to preload before starting.

                              func MakeDataDir

                              func MakeDataDir(ctx *cli.Context) string

                                MakeDataDir retrieves the currently requested data directory, terminating if none (or the empty string) is specified. If the node is starting a testnet, then a subdirectory of the specified datadir will be used.

                                func MakeDatabaseHandles

                                func MakeDatabaseHandles() int

                                  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 MakeGenesis

                                  func MakeGenesis(ctx *cli.Context) *core.Genesis

                                  func MakePasswordList

                                  func MakePasswordList(ctx *cli.Context) []string

                                    MakePasswordList reads password lines from the file specified by the global --password flag.

                                    func MigrateFlags

                                    func MigrateFlags(action func(ctx *cli.Context) error) func(*cli.Context) error

                                      MigrateFlags sets the global flag from a local flag when it's set. This is a temporary function used for migrating old command/flags to the new format.

                                      e.g. geth account new --keystore /tmp/mykeystore --lightkdf

                                      is equivalent after calling this method with:

                                      geth --keystore /tmp/mykeystore --lightkdf account new

                                      This allows the use of the existing configuration functionality. When all flags are migrated this function can be removed and the existing configuration functionality must be changed that is uses local flags

                                      func RegisterEthService

                                      func RegisterEthService(stack *node.Node, cfg *ethconfig.Config) ethapi.Backend

                                        RegisterEthService adds an Ethereum client to the stack.

                                        func RegisterEthStatsService

                                        func RegisterEthStatsService(stack *node.Node, backend ethapi.Backend, url string)

                                          RegisterEthStatsService configures the Ethereum Stats daemon and adds it to the given node.

                                          func RegisterGraphQLService

                                          func RegisterGraphQLService(stack *node.Node, backend ethapi.Backend, cfg node.Config)

                                            RegisterGraphQLService is a utility function to construct a new service and register it against a node.

                                            func SetDNSDiscoveryDefaults

                                            func SetDNSDiscoveryDefaults(cfg *ethconfig.Config, genesis common.Hash)

                                              SetDNSDiscoveryDefaults configures DNS discovery with the given URL if no URLs are set.

                                              func SetEthConfig

                                              func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config)

                                                SetEthConfig applies eth-related command line flags to the config.

                                                func SetNodeConfig

                                                func SetNodeConfig(ctx *cli.Context, cfg *node.Config)

                                                  SetNodeConfig applies node-related command line flags to the config.

                                                  func SetP2PConfig

                                                  func SetP2PConfig(ctx *cli.Context, cfg *p2p.Config)

                                                  func SetupMetrics

                                                  func SetupMetrics(ctx *cli.Context)

                                                  func SplitAndTrim

                                                  func SplitAndTrim(input string) (ret []string)

                                                    SplitAndTrim splits input separated by a comma and trims excessive white space from the substrings.

                                                    func SplitTagsFlag

                                                    func SplitTagsFlag(tagsFlag string) map[string]string

                                                    func StartNode

                                                    func StartNode(ctx *cli.Context, stack *node.Node)

                                                    Types

                                                    type BigFlag

                                                    type BigFlag struct {
                                                    	Name   string
                                                    	Value  *big.Int
                                                    	Usage  string
                                                    	EnvVar string
                                                    }

                                                      BigFlag is a command line flag that accepts 256 bit big integers in decimal or hexadecimal syntax.

                                                      func (BigFlag) Apply

                                                      func (f BigFlag) Apply(set *flag.FlagSet)

                                                      func (BigFlag) GetName

                                                      func (f BigFlag) GetName() string

                                                      func (BigFlag) String

                                                      func (f BigFlag) String() string

                                                      type DirectoryFlag

                                                      type DirectoryFlag struct {
                                                      	Name   string
                                                      	Value  DirectoryString
                                                      	Usage  string
                                                      	EnvVar string
                                                      }

                                                        Custom cli.Flag type which expand the received string to an absolute path. e.g. ~/.ethereum -> /home/username/.ethereum

                                                        func (DirectoryFlag) Apply

                                                        func (f DirectoryFlag) Apply(set *flag.FlagSet)

                                                          called by cli library, grabs variable from environment (if in env) and adds variable to flag set for parsing.

                                                          func (DirectoryFlag) GetName

                                                          func (f DirectoryFlag) GetName() string

                                                          func (*DirectoryFlag) Set

                                                          func (f *DirectoryFlag) Set(value string)

                                                          func (DirectoryFlag) String

                                                          func (f DirectoryFlag) String() string

                                                          type DirectoryString

                                                          type DirectoryString string

                                                            Custom type which is registered in the flags library which cli uses for argument parsing. This allows us to expand Value to an absolute path when the argument is parsed

                                                            func (*DirectoryString) Set

                                                            func (s *DirectoryString) Set(value string) error

                                                            func (*DirectoryString) String

                                                            func (s *DirectoryString) String() string

                                                            type TextMarshaler

                                                            type TextMarshaler interface {
                                                            	encoding.TextMarshaler
                                                            	encoding.TextUnmarshaler
                                                            }

                                                            func GlobalTextMarshaler

                                                            func GlobalTextMarshaler(ctx *cli.Context, name string) TextMarshaler

                                                              GlobalTextMarshaler returns the value of a TextMarshalerFlag from the global flag set.

                                                              type TextMarshalerFlag

                                                              type TextMarshalerFlag struct {
                                                              	Name   string
                                                              	Value  TextMarshaler
                                                              	Usage  string
                                                              	EnvVar string
                                                              }

                                                                TextMarshalerFlag wraps a TextMarshaler value.

                                                                func (TextMarshalerFlag) Apply

                                                                func (f TextMarshalerFlag) Apply(set *flag.FlagSet)

                                                                func (TextMarshalerFlag) GetName

                                                                func (f TextMarshalerFlag) GetName() string

                                                                func (TextMarshalerFlag) String

                                                                func (f TextMarshalerFlag) String() string