2015-07-06 19:54:22 -05:00
// Copyright 2015 The go-ethereum Authors
// This file is part of go-ethereum.
//
// go-ethereum is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// go-ethereum is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
2015-07-22 11:48:40 -05:00
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2015-07-06 19:54:22 -05:00
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
2015-07-22 11:48:40 -05:00
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
2015-07-06 19:54:22 -05:00
2015-03-05 20:00:41 -06:00
package utils
import (
"crypto/ecdsa"
2015-04-20 10:45:37 -05:00
"fmt"
2015-11-17 10:33:25 -06:00
"io/ioutil"
2015-10-07 10:21:13 -05:00
"math"
2015-05-09 05:00:51 -05:00
"math/big"
2016-03-24 07:06:10 -05:00
"math/rand"
2015-03-09 17:00:27 -05:00
"os"
2015-05-12 07:24:11 -05:00
"path/filepath"
2015-05-12 08:20:53 -05:00
"runtime"
2015-07-07 03:32:05 -05:00
"strconv"
2015-11-17 10:33:25 -06:00
"strings"
2016-03-24 07:06:10 -05:00
"time"
2015-05-12 07:24:11 -05:00
2015-03-05 20:00:41 -06:00
"github.com/codegangsta/cli"
2015-04-13 03:13:52 -05:00
"github.com/ethereum/ethash"
2015-03-07 05:39:52 -06:00
"github.com/ethereum/go-ethereum/accounts"
2015-03-18 02:44:58 -05:00
"github.com/ethereum/go-ethereum/common"
2015-03-05 20:00:41 -06:00
"github.com/ethereum/go-ethereum/core"
2015-11-17 10:33:25 -06:00
"github.com/ethereum/go-ethereum/core/state"
2015-03-05 20:00:41 -06:00
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/eth"
"github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/logger"
2015-04-03 10:09:01 -05:00
"github.com/ethereum/go-ethereum/logger/glog"
2015-08-07 02:56:49 -05:00
"github.com/ethereum/go-ethereum/metrics"
2015-11-17 10:33:25 -06:00
"github.com/ethereum/go-ethereum/node"
"github.com/ethereum/go-ethereum/p2p/discover"
2015-03-05 20:00:41 -06:00
"github.com/ethereum/go-ethereum/p2p/nat"
2015-10-07 10:21:13 -05:00
"github.com/ethereum/go-ethereum/params"
2016-04-21 04:14:57 -05:00
"github.com/ethereum/go-ethereum/pow"
2016-04-28 04:00:11 -05:00
"github.com/ethereum/go-ethereum/release"
2015-12-16 03:58:01 -06:00
"github.com/ethereum/go-ethereum/rpc"
2015-11-17 10:33:25 -06:00
"github.com/ethereum/go-ethereum/whisper"
2015-03-05 20:00:41 -06:00
)
2015-03-10 10:44:48 -05:00
func init ( ) {
cli . AppHelpTemplate = ` { { . Name } } { { if . Flags } } [ global options ] { { end } } command { { if . Flags } } [ command options ] { { end } } [ arguments ... ]
VERSION :
{ { . Version } }
COMMANDS :
{ { range . Commands } } { { . Name } } { { with . ShortName } } , { { . } } { { end } } { { "\t" } } { { . Usage } }
{ { end } } { { if . Flags } }
GLOBAL OPTIONS :
{ { range . Flags } } { { . } }
{ { end } } { { end } }
`
cli . CommandHelpTemplate = ` { { . Name } } { { if . Subcommands } } command { { end } } { { if . Flags } } [ command options ] { { end } } [ arguments ... ]
{ { if . Description } } { { . Description } }
{ { end } } { { if . Subcommands } }
SUBCOMMANDS :
{ { range . Subcommands } } { { . Name } } { { with . ShortName } } , { { . } } { { end } } { { "\t" } } { { . Usage } }
{ { end } } { { end } } { { if . Flags } }
OPTIONS :
{ { range . Flags } } { { . } }
{ { end } } { { end } }
`
}
2015-03-09 16:51:50 -05:00
// NewApp creates an app with sane defaults.
func NewApp ( version , usage string ) * cli . App {
app := cli . NewApp ( )
2015-05-12 07:24:11 -05:00
app . Name = filepath . Base ( os . Args [ 0 ] )
2015-03-09 16:51:50 -05:00
app . Author = ""
2015-03-25 19:03:03 -05:00
//app.Authors = nil
2015-03-09 16:51:50 -05:00
app . Email = ""
app . Version = version
app . Usage = usage
return app
}
2015-03-05 20:00:41 -06:00
// These are all the command line flags we support.
// If you add to this list, please remember to include the
// flag in the appropriate command definition.
//
// The flags are defined here so their names and help texts
// are the same for all commands.
var (
// General settings
2015-04-08 08:43:55 -05:00
DataDirFlag = DirectoryFlag {
2015-03-05 20:00:41 -06:00
Name : "datadir" ,
2015-10-29 12:53:24 -05:00
Usage : "Data directory for the databases and keystore" ,
2015-04-08 08:43:55 -05:00
Value : DirectoryString { common . DefaultDataDir ( ) } ,
2015-03-05 20:00:41 -06:00
}
2016-03-07 16:38:56 -06:00
KeyStoreDirFlag = DirectoryFlag {
Name : "keystore" ,
Usage : "Directory for the keystore (default = inside the datadir)" ,
}
2015-03-18 02:44:58 -05:00
NetworkIdFlag = cli . IntFlag {
Name : "networkid" ,
2015-10-29 12:53:24 -05:00
Usage : "Network identifier (integer, 0=Olympic, 1=Frontier, 2=Morden)" ,
2015-03-18 02:44:58 -05:00
Value : eth . NetworkId ,
}
2015-10-29 12:53:24 -05:00
OlympicFlag = cli . BoolFlag {
Name : "olympic" ,
Usage : "Olympic network: pre-configured pre-release test network" ,
2015-06-08 05:12:13 -05:00
}
2015-10-29 12:53:24 -05:00
TestNetFlag = cli . BoolFlag {
Name : "testnet" ,
Usage : "Morden network: pre-configured test network with modified starting nonces (replay protection)" ,
2015-07-10 07:29:40 -05:00
}
2015-09-06 08:46:54 -05:00
DevModeFlag = cli . BoolFlag {
Name : "dev" ,
2015-10-29 12:53:24 -05:00
Usage : "Developer mode: pre-configured private network with several debugging flags" ,
2015-09-06 08:46:54 -05:00
}
2015-10-29 12:53:24 -05:00
GenesisFileFlag = cli . StringFlag {
Name : "genesis" ,
Usage : "Insert/overwrite the genesis block (JSON format)" ,
2015-10-05 06:01:34 -05:00
}
2015-04-18 16:53:30 -05:00
IdentityFlag = cli . StringFlag {
Name : "identity" ,
2015-04-21 18:41:34 -05:00
Usage : "Custom node name" ,
2015-04-18 16:53:30 -05:00
}
2015-04-08 06:22:31 -05:00
NatspecEnabledFlag = cli . BoolFlag {
Name : "natspec" ,
Usage : "Enable NatSpec confirmation notice" ,
}
2015-10-26 16:24:09 -05:00
DocRootFlag = DirectoryFlag {
Name : "docroot" ,
Usage : "Document Root for HTTPClient file scheme" ,
Value : DirectoryString { common . HomeDir ( ) } ,
}
2015-07-22 05:46:20 -05:00
CacheFlag = cli . IntFlag {
Name : "cache" ,
2015-10-29 12:53:24 -05:00
Usage : "Megabytes of memory allocated to internal caching (min 16MB / database forced)" ,
2016-02-19 06:29:19 -06:00
Value : 128 ,
2015-07-22 05:46:20 -05:00
}
2015-10-29 12:53:24 -05:00
BlockchainVersionFlag = cli . IntFlag {
Name : "blockchainversion" ,
Usage : "Blockchain version (integer)" ,
Value : core . BlockChainVersion ,
2015-08-03 10:48:24 -05:00
}
2015-10-09 10:36:31 -05:00
FastSyncFlag = cli . BoolFlag {
Name : "fast" ,
2015-11-10 07:47:19 -06:00
Usage : "Enable fast syncing through state downloads" ,
2015-07-02 11:55:18 -05:00
}
2015-10-23 09:49:36 -05:00
LightKDFFlag = cli . BoolFlag {
Name : "lightkdf" ,
2015-11-10 07:47:19 -06:00
Usage : "Reduce key-derivation RAM & CPU usage at some expense of KDF strength" ,
2015-10-23 09:49:36 -05:00
}
2015-10-29 12:53:24 -05:00
// Miner settings
2015-06-12 00:45:23 -05:00
// TODO: refactor CPU vs GPU mining flags
2015-10-29 12:53:24 -05:00
MiningEnabledFlag = cli . BoolFlag {
Name : "mine" ,
Usage : "Enable mining" ,
2015-06-12 00:45:23 -05:00
}
2015-03-05 20:00:41 -06:00
MinerThreadsFlag = cli . IntFlag {
Name : "minerthreads" ,
2015-10-29 12:53:24 -05:00
Usage : "Number of CPU threads to use for mining" ,
2015-03-05 20:00:41 -06:00
Value : runtime . NumCPU ( ) ,
}
2015-10-29 12:53:24 -05:00
MiningGPUFlag = cli . StringFlag {
Name : "minergpus" ,
Usage : "List of GPUs to use for mining (e.g. '0,1' will use the first two GPUs found)" ,
2015-03-05 20:00:41 -06:00
}
2016-03-01 16:32:43 -06:00
TargetGasLimitFlag = cli . StringFlag {
Name : "targetgaslimit" ,
Usage : "Target gas limit sets the artificial target gas floor for the blocks to mine" ,
Value : params . GenesisGasLimit . String ( ) ,
}
2015-05-20 10:56:17 -05:00
AutoDAGFlag = cli . BoolFlag {
Name : "autodag" ,
Usage : "Enable automatic DAG pregeneration" ,
}
2015-03-26 16:49:22 -05:00
EtherbaseFlag = cli . StringFlag {
2015-03-27 06:14:00 -05:00
Name : "etherbase" ,
2015-10-29 12:53:24 -05:00
Usage : "Public address for block mining rewards (default = first account created)" ,
2015-07-07 03:32:05 -05:00
Value : "0" ,
2015-03-26 16:49:22 -05:00
}
2015-05-09 05:00:51 -05:00
GasPriceFlag = cli . StringFlag {
Name : "gasprice" ,
2015-10-29 12:53:24 -05:00
Usage : "Minimal gas price to accept for mining a transactions" ,
2016-02-29 07:15:18 -06:00
Value : new ( big . Int ) . Mul ( big . NewInt ( 20 ) , common . Shannon ) . String ( ) ,
2015-05-09 05:00:51 -05:00
}
2015-09-22 03:34:58 -05:00
ExtraDataFlag = cli . StringFlag {
Name : "extradata" ,
2015-10-29 12:53:24 -05:00
Usage : "Block extra data set by the miner (default = client version)" ,
2015-09-22 03:34:58 -05:00
}
2015-10-29 12:53:24 -05:00
// Account settings
2015-03-18 02:44:58 -05:00
UnlockedAccountFlag = cli . StringFlag {
Name : "unlock" ,
2015-11-17 10:33:25 -06:00
Usage : "Comma separated list of accounts to unlock" ,
2015-03-23 08:00:06 -05:00
Value : "" ,
}
PasswordFileFlag = cli . StringFlag {
Name : "password" ,
2015-11-17 10:33:25 -06:00
Usage : "Password file to use for non-inteactive password input" ,
2015-03-23 08:00:06 -05:00
Value : "" ,
2015-03-18 02:44:58 -05:00
}
2015-03-05 20:00:41 -06:00
2015-07-17 16:09:36 -05:00
VMForceJitFlag = cli . BoolFlag {
Name : "forcejit" ,
Usage : "Force the JIT VM to take precedence" ,
}
VMJitCacheFlag = cli . IntFlag {
Name : "jitcache" ,
Usage : "Amount of cached JIT VM programs" ,
Value : 64 ,
}
VMEnableJitFlag = cli . BoolFlag {
Name : "jitvm" ,
Usage : "Enable the JIT VM" ,
}
2015-03-18 02:44:58 -05:00
// logging and debug settings
2015-06-29 08:11:01 -05:00
MetricsEnabledFlag = cli . BoolFlag {
Name : metrics . MetricsEnabledFlag ,
2015-10-29 12:53:24 -05:00
Usage : "Enable metrics collection and reporting" ,
2015-06-29 08:11:01 -05:00
}
2016-04-21 04:14:57 -05:00
FakePoWFlag = cli . BoolFlag {
Name : "fakepow" ,
Usage : "Disables proof-of-work verification" ,
}
2015-03-05 20:00:41 -06:00
// RPC settings
RPCEnabledFlag = cli . BoolFlag {
Name : "rpc" ,
2015-10-29 12:53:24 -05:00
Usage : "Enable the HTTP-RPC server" ,
2015-03-05 20:00:41 -06:00
}
RPCListenAddrFlag = cli . StringFlag {
Name : "rpcaddr" ,
2015-10-29 12:53:24 -05:00
Usage : "HTTP-RPC server listening interface" ,
2016-02-09 05:24:42 -06:00
Value : common . DefaultHTTPHost ,
2015-03-05 20:00:41 -06:00
}
RPCPortFlag = cli . IntFlag {
Name : "rpcport" ,
2015-10-29 12:53:24 -05:00
Usage : "HTTP-RPC server listening port" ,
2016-02-09 05:24:42 -06:00
Value : common . DefaultHTTPPort ,
2015-03-05 20:00:41 -06:00
}
2015-03-29 14:21:14 -05:00
RPCCORSDomainFlag = cli . StringFlag {
Name : "rpccorsdomain" ,
2016-02-24 04:19:00 -06:00
Usage : "Comma separated list of domains from which to accept cross origin requests (browser enforced)" ,
2015-03-29 14:21:14 -05:00
Value : "" ,
}
2015-12-16 03:58:01 -06:00
RPCApiFlag = cli . StringFlag {
2015-06-16 06:30:53 -05:00
Name : "rpcapi" ,
2015-10-29 12:53:24 -05:00
Usage : "API's offered over the HTTP-RPC interface" ,
2016-02-09 05:24:42 -06:00
Value : rpc . DefaultHTTPApis ,
2015-06-16 06:30:53 -05:00
}
2015-06-08 04:01:02 -05:00
IPCDisabledFlag = cli . BoolFlag {
Name : "ipcdisable" ,
Usage : "Disable the IPC-RPC server" ,
}
IPCApiFlag = cli . StringFlag {
Name : "ipcapi" ,
2015-10-29 12:53:24 -05:00
Usage : "API's offered over the IPC-RPC interface" ,
2016-02-09 05:24:42 -06:00
Value : rpc . DefaultIPCApis ,
2015-06-08 04:01:02 -05:00
}
IPCPathFlag = DirectoryFlag {
Name : "ipcpath" ,
2016-02-02 11:06:43 -06:00
Usage : "Filename for IPC socket/pipe within the datadir (explicit paths escape it)" ,
2016-02-09 05:24:42 -06:00
Value : DirectoryString { common . DefaultIPCSocket } ,
2015-06-08 04:01:02 -05:00
}
2015-12-16 03:58:01 -06:00
WSEnabledFlag = cli . BoolFlag {
2016-01-26 07:39:21 -06:00
Name : "ws" ,
2015-12-16 03:58:01 -06:00
Usage : "Enable the WS-RPC server" ,
}
WSListenAddrFlag = cli . StringFlag {
Name : "wsaddr" ,
Usage : "WS-RPC server listening interface" ,
2016-02-09 05:24:42 -06:00
Value : common . DefaultWSHost ,
2015-12-16 03:58:01 -06:00
}
WSPortFlag = cli . IntFlag {
Name : "wsport" ,
Usage : "WS-RPC server listening port" ,
2016-02-09 05:24:42 -06:00
Value : common . DefaultWSPort ,
2015-12-16 03:58:01 -06:00
}
WSApiFlag = cli . StringFlag {
Name : "wsapi" ,
Usage : "API's offered over the WS-RPC interface" ,
2016-02-09 05:24:42 -06:00
Value : rpc . DefaultHTTPApis ,
2015-12-16 03:58:01 -06:00
}
2016-03-14 03:38:54 -05:00
WSAllowedOriginsFlag = cli . StringFlag {
Name : "wsorigins" ,
Usage : "Origins from which to accept websockets requests" ,
2015-12-16 03:58:01 -06:00
Value : "" ,
2015-10-15 09:07:19 -05:00
}
2015-06-19 07:04:18 -05:00
ExecFlag = cli . StringFlag {
Name : "exec" ,
2015-10-29 12:53:24 -05:00
Usage : "Execute JavaScript statement (only in combination with console/attach)" ,
2015-06-19 07:04:18 -05:00
}
2016-05-06 04:40:23 -05:00
PreloadJSFlag = cli . StringFlag {
2016-04-07 06:48:24 -05:00
Name : "preload" ,
Usage : "Comma separated list of JavaScript files to preload into the console" ,
}
2016-01-26 07:39:21 -06:00
2015-03-05 20:00:41 -06:00
// Network Settings
MaxPeersFlag = cli . IntFlag {
Name : "maxpeers" ,
2015-04-21 18:41:34 -05:00
Usage : "Maximum number of network peers (network disabled if set to 0)" ,
2015-05-08 09:01:31 -05:00
Value : 25 ,
2015-03-05 20:00:41 -06:00
}
2015-05-04 09:35:49 -05:00
MaxPendingPeersFlag = cli . IntFlag {
Name : "maxpendpeers" ,
Usage : "Maximum number of pending connection attempts (defaults used if set to 0)" ,
Value : 0 ,
}
2015-03-05 20:00:41 -06:00
ListenPortFlag = cli . IntFlag {
Name : "port" ,
Usage : "Network listening port" ,
Value : 30303 ,
}
BootnodesFlag = cli . StringFlag {
Name : "bootnodes" ,
2015-11-17 10:33:25 -06:00
Usage : "Comma separated enode URLs for P2P discovery bootstrap" ,
2015-03-05 20:00:41 -06:00
Value : "" ,
}
NodeKeyFileFlag = cli . StringFlag {
Name : "nodekey" ,
Usage : "P2P node key file" ,
}
NodeKeyHexFlag = cli . StringFlag {
Name : "nodekeyhex" ,
Usage : "P2P node key as hex (for testing)" ,
}
NATFlag = cli . StringFlag {
Name : "nat" ,
2015-04-21 18:41:34 -05:00
Usage : "NAT port mapping mechanism (any|none|upnp|pmp|extip:<IP>)" ,
2015-03-05 20:00:41 -06:00
Value : "any" ,
}
2015-05-26 11:07:24 -05:00
NoDiscoverFlag = cli . BoolFlag {
Name : "nodiscover" ,
Usage : "Disables the peer discovery mechanism (manual peer addition)" ,
}
2015-04-20 10:45:37 -05:00
WhisperEnabledFlag = cli . BoolFlag {
Name : "shh" ,
2015-10-29 12:53:24 -05:00
Usage : "Enable Whisper" ,
2015-04-20 10:45:37 -05:00
}
2015-04-22 17:11:11 -05:00
// ATM the url is left to the user and deployment to
2015-03-15 01:31:40 -05:00
JSpathFlag = cli . StringFlag {
Name : "jspath" ,
2016-02-05 08:32:00 -06:00
Usage : "JavaScript root path for `loadScript` and document root for `admin.httpGet`" ,
2015-03-15 01:31:40 -05:00
Value : "." ,
}
2015-04-22 17:11:11 -05:00
SolcPathFlag = cli . StringFlag {
Name : "solc" ,
2015-10-29 12:53:24 -05:00
Usage : "Solidity compiler command to be used" ,
2015-04-22 17:11:11 -05:00
Value : "solc" ,
}
2015-10-29 12:53:24 -05:00
// Gas price oracle settings
2015-05-26 07:17:43 -05:00
GpoMinGasPriceFlag = cli . StringFlag {
Name : "gpomin" ,
Usage : "Minimum suggested gas price" ,
2016-02-29 07:15:18 -06:00
Value : new ( big . Int ) . Mul ( big . NewInt ( 20 ) , common . Shannon ) . String ( ) ,
2015-05-26 07:17:43 -05:00
}
GpoMaxGasPriceFlag = cli . StringFlag {
Name : "gpomax" ,
Usage : "Maximum suggested gas price" ,
2015-08-02 19:46:34 -05:00
Value : new ( big . Int ) . Mul ( big . NewInt ( 500 ) , common . Shannon ) . String ( ) ,
2015-05-26 07:17:43 -05:00
}
GpoFullBlockRatioFlag = cli . IntFlag {
Name : "gpofull" ,
Usage : "Full block threshold for gas price calculation (%)" ,
Value : 80 ,
}
GpobaseStepDownFlag = cli . IntFlag {
Name : "gpobasedown" ,
Usage : "Suggested gas price base step down ratio (1/1000)" ,
Value : 10 ,
}
GpobaseStepUpFlag = cli . IntFlag {
Name : "gpobaseup" ,
Usage : "Suggested gas price base step up ratio (1/1000)" ,
Value : 100 ,
}
GpobaseCorrectionFactorFlag = cli . IntFlag {
Name : "gpobasecf" ,
Usage : "Suggested gas price base correction factor (%)" ,
Value : 110 ,
}
2015-03-05 20:00:41 -06:00
)
2015-11-17 10:33:25 -06:00
// MustMakeDataDir 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 MustMakeDataDir ( ctx * cli . Context ) string {
if path := ctx . GlobalString ( DataDirFlag . Name ) ; path != "" {
if ctx . GlobalBool ( TestNetFlag . Name ) {
return filepath . Join ( path , "/testnet" )
}
return path
2015-03-05 20:00:41 -06:00
}
2015-11-17 10:33:25 -06:00
Fatalf ( "Cannot determine default data directory, please set manually (--datadir)" )
return ""
2015-03-05 20:00:41 -06:00
}
2016-03-07 16:38:56 -06:00
// MakeKeyStoreDir resolves the folder to use for storing the account keys from the
// set command line flags, returning the explicitly requested path, or one inside
// the data directory otherwise.
func MakeKeyStoreDir ( datadir string , ctx * cli . Context ) string {
if path := ctx . GlobalString ( KeyStoreDirFlag . Name ) ; path != "" {
return path
}
return filepath . Join ( datadir , "keystore" )
}
2016-02-09 05:24:42 -06:00
// MakeIPCPath creates an IPC path configuration from the set command line flags,
2016-02-02 11:06:43 -06:00
// returning an empty string if IPC was explicitly disabled, or the set path.
2016-02-09 05:24:42 -06:00
func MakeIPCPath ( ctx * cli . Context ) string {
2016-02-02 11:06:43 -06:00
if ctx . GlobalBool ( IPCDisabledFlag . Name ) {
return ""
}
return ctx . GlobalString ( IPCPathFlag . Name )
}
2015-11-17 10:33:25 -06:00
// MakeNodeKey creates a node key from set command line flags, either loading it
// from a file or as a specified hex value. If neither flags were provided, this
// method returns nil and an emphemeral key is to be generated.
func MakeNodeKey ( ctx * cli . Context ) * ecdsa . PrivateKey {
var (
hex = ctx . GlobalString ( NodeKeyHexFlag . Name )
file = ctx . GlobalString ( NodeKeyFileFlag . Name )
key * ecdsa . PrivateKey
err error
)
2015-03-05 20:00:41 -06:00
switch {
case file != "" && hex != "" :
Fatalf ( "Options %q and %q are mutually exclusive" , NodeKeyFileFlag . Name , NodeKeyHexFlag . Name )
2015-11-17 10:33:25 -06:00
2015-03-05 20:00:41 -06:00
case file != "" :
if key , err = crypto . LoadECDSA ( file ) ; err != nil {
Fatalf ( "Option %q: %v" , NodeKeyFileFlag . Name , err )
}
2015-11-17 10:33:25 -06:00
2015-03-05 20:00:41 -06:00
case hex != "" :
if key , err = crypto . HexToECDSA ( hex ) ; err != nil {
Fatalf ( "Option %q: %v" , NodeKeyHexFlag . Name , err )
}
}
return key
}
2015-11-17 10:33:25 -06:00
// MakeNodeName creates a node name from a base set and the command line flags.
func MakeNodeName ( client , version string , ctx * cli . Context ) string {
name := common . MakeName ( client , version )
if identity := ctx . GlobalString ( IdentityFlag . Name ) ; len ( identity ) > 0 {
name += "/" + identity
}
if ctx . GlobalBool ( VMEnableJitFlag . Name ) {
name += "/JIT"
2015-04-18 16:53:30 -05:00
}
2015-11-17 10:33:25 -06:00
return name
}
// MakeBootstrapNodes creates a list of bootstrap nodes from the command line
// flags, reverting to pre-configured ones if none have been specified.
func MakeBootstrapNodes ( ctx * cli . Context ) [ ] * discover . Node {
// Return pre-configured nodes if none were manually requested
if ! ctx . GlobalIsSet ( BootnodesFlag . Name ) {
if ctx . GlobalBool ( TestNetFlag . Name ) {
return TestNetBootNodes
}
return FrontierBootNodes
}
// Otherwise parse and use the CLI bootstrap nodes
bootnodes := [ ] * discover . Node { }
for _ , url := range strings . Split ( ctx . GlobalString ( BootnodesFlag . Name ) , "," ) {
node , err := discover . ParseNode ( url )
if err != nil {
glog . V ( logger . Error ) . Infof ( "Bootstrap URL %s: %v\n" , url , err )
continue
}
bootnodes = append ( bootnodes , node )
}
return bootnodes
}
// MakeListenAddress creates a TCP listening address string from set command
// line flags.
func MakeListenAddress ( ctx * cli . Context ) string {
return fmt . Sprintf ( ":%d" , ctx . GlobalInt ( ListenPortFlag . Name ) )
}
// MakeNAT creates a port mapper from set command line flags.
func MakeNAT ( ctx * cli . Context ) nat . Interface {
natif , err := nat . Parse ( ctx . GlobalString ( NATFlag . Name ) )
2015-07-07 05:53:36 -05:00
if err != nil {
2015-11-17 10:33:25 -06:00
Fatalf ( "Option %s: %v" , NATFlag . Name , err )
}
return natif
}
2016-04-14 09:18:35 -05:00
// MakeRPCModules splits input separated by a comma and trims excessive white
// space from the substrings.
func MakeRPCModules ( input string ) [ ] string {
result := strings . Split ( input , "," )
for i , r := range result {
result [ i ] = strings . TrimSpace ( r )
}
return result
}
2016-02-09 05:24:42 -06:00
// MakeHTTPRpcHost creates the HTTP RPC listener interface string from the set
2016-02-05 05:45:36 -06:00
// command line flags, returning empty if the HTTP endpoint is disabled.
2016-02-09 05:24:42 -06:00
func MakeHTTPRpcHost ( ctx * cli . Context ) string {
2016-02-05 05:45:36 -06:00
if ! ctx . GlobalBool ( RPCEnabledFlag . Name ) {
return ""
}
return ctx . GlobalString ( RPCListenAddrFlag . Name )
}
2016-02-09 05:24:42 -06:00
// MakeWSRpcHost creates the WebSocket RPC listener interface string from the set
2016-02-05 07:08:48 -06:00
// command line flags, returning empty if the HTTP endpoint is disabled.
2016-02-09 05:24:42 -06:00
func MakeWSRpcHost ( ctx * cli . Context ) string {
2016-02-05 07:08:48 -06:00
if ! ctx . GlobalBool ( WSEnabledFlag . Name ) {
return ""
}
return ctx . GlobalString ( WSListenAddrFlag . Name )
}
2015-11-17 10:33:25 -06:00
// MakeGenesisBlock loads up a genesis block from an input file specified in the
// command line, or returns the empty string if none set.
func MakeGenesisBlock ( ctx * cli . Context ) string {
genesis := ctx . GlobalString ( GenesisFileFlag . Name )
if genesis == "" {
return ""
}
data , err := ioutil . ReadFile ( genesis )
if err != nil {
Fatalf ( "Failed to load custom genesis file: %v" , err )
}
return string ( data )
}
2016-02-19 06:29:19 -06:00
// MakeDatabaseHandles raises out the number of allowed file handles per process
// for Geth and returns half of the allowance to assign to the database.
func MakeDatabaseHandles ( ) int {
if err := raiseFdLimit ( 2048 ) ; err != nil {
Fatalf ( "Failed to raise file descriptor allowance: %v" , err )
}
limit , err := getFdLimit ( )
if err != nil {
Fatalf ( "Failed to retrieve file descriptor allowance: %v" , err )
}
if limit > 2048 { // cap database file descriptors even if more is available
limit = 2048
}
return limit / 2 // Leave half for networking and other stuff
}
2015-11-17 10:33:25 -06:00
// MakeAccountManager creates an account manager from set command line flags.
func MakeAccountManager ( ctx * cli . Context ) * accounts . Manager {
// Create the keystore crypto primitive, light if requested
2016-03-02 06:57:15 -06:00
scryptN := accounts . StandardScryptN
scryptP := accounts . StandardScryptP
2015-11-17 10:33:25 -06:00
if ctx . GlobalBool ( LightKDFFlag . Name ) {
2016-03-02 06:57:15 -06:00
scryptN = accounts . LightScryptN
scryptP = accounts . LightScryptP
2015-11-17 10:33:25 -06:00
}
2016-03-02 06:57:15 -06:00
datadir := MustMakeDataDir ( ctx )
keydir := MakeKeyStoreDir ( datadir , ctx )
return accounts . NewManager ( keydir , scryptN , scryptP )
2015-11-17 10:33:25 -06:00
}
// MakeAddress converts an account specified directly as a hex encoded string or
// a key index in the key store to an internal account representation.
2016-03-02 18:09:16 -06:00
func MakeAddress ( accman * accounts . Manager , account string ) ( accounts . Account , error ) {
2015-11-17 10:33:25 -06:00
// If the specified account is a valid address, return it
if common . IsHexAddress ( account ) {
2016-03-02 18:09:16 -06:00
return accounts . Account { Address : common . HexToAddress ( account ) } , nil
2015-11-17 10:33:25 -06:00
}
// Otherwise try to interpret the account as a keystore index
index , err := strconv . Atoi ( account )
if err != nil {
2016-03-02 18:09:16 -06:00
return accounts . Account { } , fmt . Errorf ( "invalid account address or index %q" , account )
2015-11-17 10:33:25 -06:00
}
2016-03-02 18:09:16 -06:00
return accman . AccountByIndex ( index )
2015-11-17 10:33:25 -06:00
}
// MakeEtherbase retrieves the etherbase either from the directly specified
// command line flags or from the keystore if CLI indexed.
func MakeEtherbase ( accman * accounts . Manager , ctx * cli . Context ) common . Address {
2016-03-02 18:09:16 -06:00
accounts := accman . Accounts ( )
2015-12-01 04:20:49 -06:00
if ! ctx . GlobalIsSet ( EtherbaseFlag . Name ) && len ( accounts ) == 0 {
2015-07-07 05:53:36 -05:00
glog . V ( logger . Error ) . Infoln ( "WARNING: No etherbase set and no accounts found as default" )
2015-11-17 10:33:25 -06:00
return common . Address { }
}
2015-12-01 04:20:49 -06:00
etherbase := ctx . GlobalString ( EtherbaseFlag . Name )
if etherbase == "" {
return common . Address { }
2015-11-17 10:33:25 -06:00
}
2015-12-01 04:20:49 -06:00
// If the specified etherbase is a valid address, return it
2016-03-02 18:09:16 -06:00
account , err := MakeAddress ( accman , etherbase )
2015-11-17 10:33:25 -06:00
if err != nil {
2015-12-01 04:20:49 -06:00
Fatalf ( "Option %q: %v" , EtherbaseFlag . Name , err )
2015-11-17 10:33:25 -06:00
}
2016-03-02 18:09:16 -06:00
return account . Address
2015-11-17 10:33:25 -06:00
}
// MakeMinerExtra resolves extradata for the miner from the set command line flags
// or returns a default one composed on the client, runtime and OS metadata.
func MakeMinerExtra ( extra [ ] byte , ctx * cli . Context ) [ ] byte {
if ctx . GlobalIsSet ( ExtraDataFlag . Name ) {
return [ ] byte ( ctx . GlobalString ( ExtraDataFlag . Name ) )
2015-07-07 05:53:36 -05:00
}
2015-11-17 10:33:25 -06:00
return extra
}
2016-03-30 16:20:06 -05:00
// MakePasswordList reads password lines from the file specified by --password.
2015-11-17 10:33:25 -06:00
func MakePasswordList ( ctx * cli . Context ) [ ] string {
2016-03-30 16:20:06 -05:00
path := ctx . GlobalString ( PasswordFileFlag . Name )
if path == "" {
return nil
}
text , err := ioutil . ReadFile ( path )
if err != nil {
Fatalf ( "Failed to read password file: %v" , err )
}
lines := strings . Split ( string ( text ) , "\n" )
// Sanitise DOS line endings.
for i := range lines {
lines [ i ] = strings . TrimRight ( lines [ i ] , "\r" )
2015-11-17 10:33:25 -06:00
}
2016-03-30 16:20:06 -05:00
return lines
2015-11-17 10:33:25 -06:00
}
// MakeSystemNode sets up a local node, configures the services to launch and
// assembles the P2P protocol stack.
2016-04-28 04:00:11 -05:00
func MakeSystemNode ( name , version string , relconf release . Config , extra [ ] byte , ctx * cli . Context ) * node . Node {
2015-11-17 10:33:25 -06:00
// Avoid conflicting network flags
networks , netFlags := 0 , [ ] cli . BoolFlag { DevModeFlag , TestNetFlag , OlympicFlag }
for _ , flag := range netFlags {
if ctx . GlobalBool ( flag . Name ) {
networks ++
}
}
if networks > 1 {
Fatalf ( "The %v flags are mutually exclusive" , netFlags )
}
// Configure the node's service container
stackConf := & node . Config {
DataDir : MustMakeDataDir ( ctx ) ,
PrivateKey : MakeNodeKey ( ctx ) ,
Name : MakeNodeName ( name , version , ctx ) ,
NoDiscovery : ctx . GlobalBool ( NoDiscoverFlag . Name ) ,
BootstrapNodes : MakeBootstrapNodes ( ctx ) ,
ListenAddr : MakeListenAddress ( ctx ) ,
NAT : MakeNAT ( ctx ) ,
MaxPeers : ctx . GlobalInt ( MaxPeersFlag . Name ) ,
MaxPendingPeers : ctx . GlobalInt ( MaxPendingPeersFlag . Name ) ,
2016-02-09 05:24:42 -06:00
IPCPath : MakeIPCPath ( ctx ) ,
HTTPHost : MakeHTTPRpcHost ( ctx ) ,
HTTPPort : ctx . GlobalInt ( RPCPortFlag . Name ) ,
HTTPCors : ctx . GlobalString ( RPCCORSDomainFlag . Name ) ,
2016-04-14 09:18:35 -05:00
HTTPModules : MakeRPCModules ( ctx . GlobalString ( RPCApiFlag . Name ) ) ,
2016-02-09 05:24:42 -06:00
WSHost : MakeWSRpcHost ( ctx ) ,
WSPort : ctx . GlobalInt ( WSPortFlag . Name ) ,
2016-03-14 03:38:54 -05:00
WSOrigins : ctx . GlobalString ( WSAllowedOriginsFlag . Name ) ,
2016-04-14 09:18:35 -05:00
WSModules : MakeRPCModules ( ctx . GlobalString ( WSApiFlag . Name ) ) ,
2015-11-17 10:33:25 -06:00
}
// Configure the Ethereum service
accman := MakeAccountManager ( ctx )
2016-03-24 07:06:10 -05:00
// initialise new random number generator
rand := rand . New ( rand . NewSource ( time . Now ( ) . UnixNano ( ) ) )
// get enabled jit flag
jitEnabled := ctx . GlobalBool ( VMEnableJitFlag . Name )
// if the jit is not enabled enable it for 10 pct of the people
if ! jitEnabled && rand . Float64 ( ) < 0.1 {
jitEnabled = true
glog . V ( logger . Info ) . Infoln ( "You're one of the lucky few that will try out the JIT VM (random). If you get a consensus failure please be so kind to report this incident with the block hash that failed. You can switch to the regular VM by setting --jitvm=false" )
}
2015-11-17 10:33:25 -06:00
ethConf := & eth . Config {
2016-03-01 16:32:43 -06:00
ChainConfig : MustMakeChainConfig ( ctx ) ,
2015-11-17 10:33:25 -06:00
Genesis : MakeGenesisBlock ( ctx ) ,
2015-10-09 10:36:31 -05:00
FastSync : ctx . GlobalBool ( FastSyncFlag . Name ) ,
2015-05-26 07:17:43 -05:00
BlockChainVersion : ctx . GlobalInt ( BlockchainVersionFlag . Name ) ,
2015-07-22 05:46:20 -05:00
DatabaseCache : ctx . GlobalInt ( CacheFlag . Name ) ,
2016-02-19 06:29:19 -06:00
DatabaseHandles : MakeDatabaseHandles ( ) ,
2015-05-26 07:17:43 -05:00
NetworkId : ctx . GlobalInt ( NetworkIdFlag . Name ) ,
2015-11-17 10:33:25 -06:00
AccountManager : accman ,
Etherbase : MakeEtherbase ( accman , ctx ) ,
2015-05-26 07:17:43 -05:00
MinerThreads : ctx . GlobalInt ( MinerThreadsFlag . Name ) ,
2015-11-17 10:33:25 -06:00
ExtraData : MakeMinerExtra ( extra , ctx ) ,
2015-05-26 07:17:43 -05:00
NatSpec : ctx . GlobalBool ( NatspecEnabledFlag . Name ) ,
2015-10-26 16:24:09 -05:00
DocRoot : ctx . GlobalString ( DocRootFlag . Name ) ,
2016-03-24 07:06:10 -05:00
EnableJit : jitEnabled ,
2016-03-19 12:07:09 -05:00
ForceJit : ctx . GlobalBool ( VMForceJitFlag . Name ) ,
2015-05-26 07:17:43 -05:00
GasPrice : common . String2Big ( ctx . GlobalString ( GasPriceFlag . Name ) ) ,
GpoMinGasPrice : common . String2Big ( ctx . GlobalString ( GpoMinGasPriceFlag . Name ) ) ,
GpoMaxGasPrice : common . String2Big ( ctx . GlobalString ( GpoMaxGasPriceFlag . Name ) ) ,
GpoFullBlockRatio : ctx . GlobalInt ( GpoFullBlockRatioFlag . Name ) ,
GpobaseStepDown : ctx . GlobalInt ( GpobaseStepDownFlag . Name ) ,
GpobaseStepUp : ctx . GlobalInt ( GpobaseStepUpFlag . Name ) ,
GpobaseCorrectionFactor : ctx . GlobalInt ( GpobaseCorrectionFactorFlag . Name ) ,
SolcPath : ctx . GlobalString ( SolcPathFlag . Name ) ,
AutoDAG : ctx . GlobalBool ( AutoDAGFlag . Name ) || ctx . GlobalBool ( MiningEnabledFlag . Name ) ,
2015-03-13 12:30:45 -05:00
}
2015-11-17 10:33:25 -06:00
// Configure the Whisper service
shhEnable := ctx . GlobalBool ( WhisperEnabledFlag . Name )
2015-09-06 08:46:54 -05:00
2015-11-17 10:33:25 -06:00
// Override any default configs in dev mode or the test net
switch {
case ctx . GlobalBool ( OlympicFlag . Name ) :
if ! ctx . GlobalIsSet ( NetworkIdFlag . Name ) {
ethConf . NetworkId = 1
}
if ! ctx . GlobalIsSet ( GenesisFileFlag . Name ) {
ethConf . Genesis = core . OlympicGenesisBlock ( )
}
2015-10-05 06:01:34 -05:00
2015-11-17 10:33:25 -06:00
case ctx . GlobalBool ( TestNetFlag . Name ) :
if ! ctx . GlobalIsSet ( NetworkIdFlag . Name ) {
ethConf . NetworkId = 2
}
if ! ctx . GlobalIsSet ( GenesisFileFlag . Name ) {
ethConf . Genesis = core . TestNetGenesisBlock ( )
}
state . StartingNonce = 1048576 // (2**20)
2015-10-05 06:01:34 -05:00
2015-11-17 10:33:25 -06:00
case ctx . GlobalBool ( DevModeFlag . Name ) :
// Override the base network stack configs
if ! ctx . GlobalIsSet ( DataDirFlag . Name ) {
stackConf . DataDir = filepath . Join ( os . TempDir ( ) , "/ethereum_dev_mode" )
2015-09-06 08:46:54 -05:00
}
if ! ctx . GlobalIsSet ( MaxPeersFlag . Name ) {
2015-11-17 10:33:25 -06:00
stackConf . MaxPeers = 0
2015-09-06 08:46:54 -05:00
}
if ! ctx . GlobalIsSet ( ListenPortFlag . Name ) {
2015-11-17 10:33:25 -06:00
stackConf . ListenAddr = ":0"
}
// Override the Ethereum protocol configs
if ! ctx . GlobalIsSet ( GenesisFileFlag . Name ) {
ethConf . Genesis = core . OlympicGenesisBlock ( )
}
if ! ctx . GlobalIsSet ( GasPriceFlag . Name ) {
ethConf . GasPrice = new ( big . Int )
2015-09-06 08:46:54 -05:00
}
if ! ctx . GlobalIsSet ( WhisperEnabledFlag . Name ) {
2015-11-17 10:33:25 -06:00
shhEnable = true
2015-09-06 08:46:54 -05:00
}
2015-11-17 10:33:25 -06:00
ethConf . PowTest = true
2015-09-06 08:46:54 -05:00
}
2015-11-17 10:33:25 -06:00
// Assemble and return the protocol stack
stack , err := node . New ( stackConf )
if err != nil {
Fatalf ( "Failed to create the protocol stack: %v" , err )
}
2015-11-26 10:35:44 -06:00
if err := stack . Register ( func ( ctx * node . ServiceContext ) ( node . Service , error ) {
2015-11-17 10:33:25 -06:00
return eth . New ( ctx , ethConf )
} ) ; err != nil {
Fatalf ( "Failed to register the Ethereum service: %v" , err )
}
if shhEnable {
2015-11-26 10:35:44 -06:00
if err := stack . Register ( func ( * node . ServiceContext ) ( node . Service , error ) { return whisper . New ( ) , nil } ) ; err != nil {
2015-11-17 10:33:25 -06:00
Fatalf ( "Failed to register the Whisper service: %v" , err )
}
}
2016-04-28 04:00:11 -05:00
if err := stack . Register ( func ( ctx * node . ServiceContext ) ( node . Service , error ) {
return release . NewReleaseService ( ctx , relconf )
} ) ; err != nil {
Fatalf ( "Failed to register the Geth release oracle service: %v" , err )
2015-11-24 04:30:35 -06:00
}
2015-11-17 10:33:25 -06:00
return stack
2015-03-05 20:00:41 -06:00
}
2015-10-07 10:21:13 -05:00
// SetupNetwork configures the system for either the main net or some test network.
func SetupNetwork ( ctx * cli . Context ) {
switch {
case ctx . GlobalBool ( OlympicFlag . Name ) :
params . DurationLimit = big . NewInt ( 8 )
params . GenesisGasLimit = big . NewInt ( 3141592 )
params . MinGasLimit = big . NewInt ( 125000 )
params . MaximumExtraDataSize = big . NewInt ( 1024 )
NetworkIdFlag . Value = 0
core . BlockReward = big . NewInt ( 1.5e+18 )
core . ExpDiffPeriod = big . NewInt ( math . MaxInt64 )
}
2016-03-01 16:32:43 -06:00
params . TargetGasLimit = common . String2Big ( ctx . GlobalString ( TargetGasLimitFlag . Name ) )
2015-10-07 10:21:13 -05:00
}
2016-04-07 04:25:28 -05:00
// MustMakeChainConfig reads the chain configuration from the database in ctx.Datadir.
2016-03-01 16:32:43 -06:00
func MustMakeChainConfig ( ctx * cli . Context ) * core . ChainConfig {
2016-04-07 04:25:28 -05:00
db := MakeChainDatabase ( ctx )
2016-03-01 16:32:43 -06:00
defer db . Close ( )
2016-04-07 04:25:28 -05:00
return MustMakeChainConfigFromDb ( ctx , db )
}
// MustMakeChainConfigFromDb reads the chain configuration from the given database.
func MustMakeChainConfigFromDb ( ctx * cli . Context , db ethdb . Database ) * core . ChainConfig {
genesis := core . GetBlock ( db , core . GetCanonicalHash ( db , 0 ) )
2016-04-01 14:54:51 -05:00
if genesis != nil {
2016-04-07 04:25:28 -05:00
// Existing genesis block, use stored config if available.
2016-04-01 14:54:51 -05:00
storedConfig , err := core . GetChainConfig ( db , genesis . Hash ( ) )
if err == nil {
return storedConfig
} else if err != core . ChainConfigNotFoundErr {
2016-03-01 16:32:43 -06:00
Fatalf ( "Could not make chain configuration: %v" , err )
}
}
2016-04-01 14:54:51 -05:00
var homesteadBlockNo * big . Int
if ctx . GlobalBool ( TestNetFlag . Name ) {
homesteadBlockNo = params . TestNetHomesteadBlock
} else {
homesteadBlockNo = params . MainNetHomesteadBlock
}
return & core . ChainConfig { HomesteadBlock : homesteadBlockNo }
2015-07-17 16:09:36 -05:00
}
2016-03-01 16:32:43 -06:00
// MakeChainDatabase open an LevelDB using the flags passed to the client and will hard crash if it fails.
func MakeChainDatabase ( ctx * cli . Context ) ethdb . Database {
var (
datadir = MustMakeDataDir ( ctx )
cache = ctx . GlobalInt ( CacheFlag . Name )
handles = MakeDatabaseHandles ( )
)
2015-07-22 05:46:20 -05:00
2016-03-01 16:32:43 -06:00
chainDb , err := ethdb . NewLDBDatabase ( filepath . Join ( datadir , "chaindata" ) , cache , handles )
if err != nil {
2015-04-13 03:13:52 -05:00
Fatalf ( "Could not open database: %v" , err )
}
2016-03-01 16:32:43 -06:00
return chainDb
}
// MakeChain creates a chain manager from set command line flags.
func MakeChain ( ctx * cli . Context ) ( chain * core . BlockChain , chainDb ethdb . Database ) {
var err error
chainDb = MakeChainDatabase ( ctx )
2015-08-03 10:48:24 -05:00
if ctx . GlobalBool ( OlympicFlag . Name ) {
2015-11-17 10:33:25 -06:00
_ , err := core . WriteTestNetGenesisBlock ( chainDb )
2015-08-03 10:48:24 -05:00
if err != nil {
glog . Fatalln ( err )
}
}
2016-04-07 04:25:28 -05:00
chainConfig := MustMakeChainConfigFromDb ( ctx , chainDb )
2016-03-01 16:32:43 -06:00
2016-04-21 04:14:57 -05:00
pow := pow . PoW ( core . FakePow { } )
if ! ctx . GlobalBool ( FakePoWFlag . Name ) {
pow = ethash . New ( )
}
chain , err = core . NewBlockChain ( chainDb , chainConfig , pow , new ( event . TypeMux ) )
2015-06-08 05:12:13 -05:00
if err != nil {
Fatalf ( "Could not start chainmanager: %v" , err )
}
2015-08-06 12:57:39 -05:00
return chain , chainDb
2015-03-05 20:00:41 -06:00
}
2016-05-06 04:40:23 -05:00
// MakeConsolePreloads retrieves the absolute paths for the console JavaScript
// scripts to preload before starting.
func MakeConsolePreloads ( ctx * cli . Context ) [ ] string {
// Skip preloading if there's nothing to preload
if ctx . GlobalString ( PreloadJSFlag . Name ) == "" {
return nil
}
// Otherwise resolve absolute paths and return them
preloads := [ ] string { }
assets := ctx . GlobalString ( JSpathFlag . Name )
for _ , file := range strings . Split ( ctx . GlobalString ( PreloadJSFlag . Name ) , "," ) {
preloads = append ( preloads , common . AbsolutePath ( assets , strings . TrimSpace ( file ) ) )
}
return preloads
}