Documentation

Overview

    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()},
    	}
    	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",
    	}
    	NetworkIdFlag = cli.Uint64Flag{
    		Name:  "networkid",
    		Usage: "Network identifier (integer, 1=Frontier, 2=Morden (disused), 3=Ropsten, 4=Rinkeby, 5=Ottoman)",
    		Value: node.DefaultConfig.P2P.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",
    	}
    	ConstantinopleOverrideFlag = cli.Uint64Flag{
    		Name:  "override.constantinople",
    		Usage: "Manually specify constantinople fork-block, overriding the bundled setting",
    	}
    	DeveloperFlag = cli.BoolFlag{
    		Name:  "dev",
    		Usage: "Ephemeral proof-of-authority network with a pre-funded developer account, mining enabled",
    	}
    	OttomanFlag = cli.BoolFlag{
    		Name:  "ottoman",
    		Usage: "Ottoman network: pre-configured istanbul bft test network",
    	}
    	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()},
    	}
    
    	SyncModeFlag = TextMarshalerFlag{
    		Name:  "syncmode",
    		Usage: `Blockchain sync mode ("fast", "full", "light", or "ultralight")`,
    		Value: &defaultSyncMode,
    	}
    	GCModeFlag = cli.StringFlag{
    		Name:  "gcmode",
    		Usage: `Blockchain garbage collection mode ("full", "archive")`,
    		Value: "full",
    	}
    	LightServFlag = cli.IntFlag{
    		Name:  "lightserv",
    		Usage: "Maximum percentage of time allowed for serving LES requests (0-90)",
    		Value: eth.DefaultConfig.LightServ,
    	}
    	LightPeersFlag = cli.IntFlag{
    		Name:  "lightpeers",
    		Usage: "Maximum number of LES client peers",
    		Value: eth.DefaultConfig.LightPeers,
    	}
    	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>)",
    	}
    	EtherbaseFlag = cli.StringFlag{
    		Name:  "etherbase",
    		Usage: "Public address for transaction broadcasting and block mining rewards (default = first account)",
    		Value: "0",
    	}
    	GatewayFeeFlag = BigFlag{
    		Name:  "gatewayfee",
    		Usage: "Minimum value of gateway fee to serve a light client transaction",
    		Value: eth.DefaultConfig.GatewayFee,
    	}
    	BLSbaseFlag = cli.StringFlag{
    		Name:  "blsbase",
    		Usage: "Public address for block mining BLS signatures (default = first account created)",
    		Value: "0",
    	}
    	// Dashboard settings
    	DashboardEnabledFlag = cli.BoolFlag{
    		Name:  metrics.DashboardEnabledFlag,
    		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",
    		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",
    		Value: 25,
    	}
    	CacheGCFlag = cli.IntFlag{
    		Name:  "cache.gc",
    		Usage: "Percentage of cache memory allowance to use for trie pruning",
    		Value: 25,
    	}
    	TrieCacheGenFlag = cli.IntFlag{
    		Name:  "trie-cache-gens",
    		Usage: "Number of trie node generations to keep in memory",
    		Value: int(state.MaxTrieCacheGen),
    	}
    	// 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.MinerGasFloor,
    	}
    	MinerLegacyGasTargetFlag = cli.Uint64Flag{
    		Name:  "targetgaslimit",
    		Usage: "Target gas floor for mined blocks (deprecated, use --miner.gastarget)",
    		Value: eth.DefaultConfig.MinerGasFloor,
    	}
    	MinerGasLimitFlag = cli.Uint64Flag{
    		Name:  "miner.gaslimit",
    		Usage: "Target gas ceiling for mined blocks",
    		Value: eth.DefaultConfig.MinerGasCeil,
    	}
    	MinerGasPriceFlag = BigFlag{
    		Name:  "miner.gasprice",
    		Usage: "Minimum gas price for mining a transaction",
    		Value: eth.DefaultConfig.MinerGasPrice,
    	}
    	MinerLegacyGasPriceFlag = BigFlag{
    		Name:  "gasprice",
    		Usage: "Minimum gas price for mining a transaction (deprecated, use --miner.gasprice)",
    		Value: eth.DefaultConfig.MinerGasPrice,
    	}
    	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.MinerRecommit,
    	}
    	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: "",
    	}
    
    	VMEnableDebugFlag = cli.BoolFlag{
    		Name:  "vmdebug",
    		Usage: "Record information useful for VM and contract debugging",
    	}
    	// 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
    	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: "",
    	}
    	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)",
    	}
    	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: "",
    	}
    	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: 25,
    	}
    	MaxPendingPeersFlag = cli.IntFlag{
    		Name:  "maxpendpeers",
    		Usage: "Maximum number of pending connection attempts (defaults used if set to 0)",
    		Value: 0,
    	}
    	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)",
    	}
    	PingIPFromPacketFlag = cli.BoolFlag{
    		Name:  "ping-ip-from-packet",
    		Usage: "Has the discovery protocol use the IP address given by a ping packet",
    	}
    	UseInMemoryDiscoverTableFlag = cli.BoolFlag{
    		Name:  "use-in-memory-discovery-table",
    		Usage: "Specifies whether to use an in memory discovery table",
    	}
    
    	VersionCheckFlag = cli.BoolFlag{
    		Name:  "disable-version-check",
    		Usage: "Disable version check. Use if the parameter is set erroneously",
    	}
    
    	// ATM the url is left to the user and deployment to
    	JSpathFlag = cli.StringFlag{
    		Name:  "jspath",
    		Usage: "JavaScript root path for `loadScript`",
    		Value: ".",
    	}
    
    	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.MetricsEnabledFlag,
    		Usage: "Enable 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: "",
    	}
    
    	// Istanbul settings
    	IstanbulRequestTimeoutFlag = cli.Uint64Flag{
    		Name:  "istanbul.requesttimeout",
    		Usage: "Timeout for each Istanbul round in milliseconds",
    		Value: eth.DefaultConfig.Istanbul.RequestTimeout,
    	}
    	IstanbulBlockPeriodFlag = cli.Uint64Flag{
    		Name:  "istanbul.blockperiod",
    		Usage: "Default minimum difference between two consecutive block's timestamps in seconds",
    		Value: eth.DefaultConfig.Istanbul.BlockPeriod,
    	}
    	IstanbulProposerPolicyFlag = cli.Uint64Flag{
    		Name:  "istanbul.proposerpolicy",
    		Usage: "Default minimum difference between two consecutive block's timestamps in seconds",
    		Value: uint64(eth.DefaultConfig.Istanbul.ProposerPolicy),
    	}
    	IstanbulLookbackWindowFlag = cli.Uint64Flag{
    		Name:  "istanbul.lookbackwindow",
    		Usage: "A validator's signature must be absent for this many consecutive blocks to be considered down for the uptime score",
    		Value: eth.DefaultConfig.Istanbul.LookbackWindow,
    	}
    
    	// Proxy node settings
    	ProxyFlag = cli.BoolFlag{
    		Name:  "proxy.proxy",
    		Usage: "Specifies whether this node is a proxy",
    	}
    	ProxyInternalFacingEndpointFlag = cli.StringFlag{
    		Name:  "proxy.internalendpoint",
    		Usage: "Specifies the internal facing endpoint for this proxy to listen to.  The format should be <ip address>:<port>",
    		Value: ":30503",
    	}
    	ProxiedValidatorAddressFlag = cli.StringFlag{
    		Name:  "proxy.proxiedvalidatoraddress",
    		Usage: "Address of the proxied validator",
    	}
    
    	// Proxied validator settings
    	ProxiedFlag = cli.BoolFlag{
    		Name:  "proxy.proxied",
    		Usage: "Specifies whether this validator will be proxied by a proxy node",
    	}
    	ProxyEnodeURLPairFlag = cli.StringFlag{
    		Name:  "proxy.proxyenodeurlpair",
    		Usage: "proxy enode URL pair separated by a semicolon.  The format should be \"<internal facing enode URL>;<external facing enode URL>\"",
    	}
    	ProxyAllowPrivateIPFlag = cli.BoolFlag{
    		Name:  "proxy.allowprivateip",
    		Usage: "Specifies whether private IP is allowed for external facing proxy enodeURL",
    	}
    )
    View Source
    var (
    	CommandHelpTemplate = `` /* 471-byte string literal not displayed */
    
    )

    Functions

    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.LDBDatabase, 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 GlobalBig

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

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

              func ImportChain

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

              func ImportPreimages

              func ImportPreimages(db *ethdb.LDBDatabase, 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) 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, the a subdirectory of the specified datadir will be used.

                          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 NewApp

                              func NewApp(gitCommit, usage string) *cli.App

                                NewApp creates an app with sane defaults.

                                func RegisterDashboardService

                                func RegisterDashboardService(stack *node.Node, cfg *dashboard.Config, commit string)

                                  RegisterDashboardService adds a dashboard to the stack.

                                  func RegisterEthService

                                  func RegisterEthService(stack *node.Node, cfg *eth.Config)

                                    RegisterEthService adds an Ethereum client to the stack.

                                    func RegisterEthStatsService

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

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

                                      func RegisterShhService

                                      func RegisterShhService(stack *node.Node, cfg *whisper.Config)

                                        RegisterShhService configures Whisper and adds it to the given node.

                                        func SetDashboardConfig

                                        func SetDashboardConfig(ctx *cli.Context, cfg *dashboard.Config)

                                          SetDashboardConfig applies dashboard related command line flags to the config.

                                          func SetEthConfig

                                          func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *eth.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 SetProxyConfig

                                              func SetProxyConfig(ctx *cli.Context, nodeCfg *node.Config, ethCfg *eth.Config)

                                                Set all of the proxy related configurations. These configs span the top level node and istanbul module configuration

                                                func SetShhConfig

                                                func SetShhConfig(ctx *cli.Context, stack *node.Node, cfg *whisper.Config)

                                                  SetShhConfig applies shh-related command line flags to the config.

                                                  func SetupMetrics

                                                  func SetupMetrics(ctx *cli.Context)

                                                  func SplitTagsFlag

                                                  func SplitTagsFlag(tagsFlag string) map[string]string

                                                  func StartNode

                                                  func StartNode(stack *node.Node)

                                                  Types

                                                  type BigFlag

                                                  type BigFlag struct {
                                                  	Name  string
                                                  	Value *big.Int
                                                  	Usage 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
                                                    }

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

                                                      func (DirectoryFlag) Apply

                                                      func (self 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 (self DirectoryFlag) GetName() string

                                                        func (*DirectoryFlag) Set

                                                        func (self *DirectoryFlag) Set(value string)

                                                        func (DirectoryFlag) String

                                                        func (self DirectoryFlag) String() string

                                                        type DirectoryString

                                                        type DirectoryString struct {
                                                        	Value 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 (self *DirectoryString) Set(value string) error

                                                          func (*DirectoryString) String

                                                          func (self *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
                                                            }

                                                              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