2015-07-06 17:54:22 -07: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 09:48:40 -07:00
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2015-07-06 17:54:22 -07:00
|
|
|
// GNU General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU General Public License
|
2015-07-22 09:48:40 -07:00
|
|
|
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
2015-07-06 17:54:22 -07:00
|
|
|
|
2016-11-25 07:55:06 -08:00
|
|
|
// Package utils contains internal helper functions for go-ethereum commands.
|
2015-03-05 18:00:41 -08:00
|
|
|
package utils
|
|
|
|
|
|
|
|
import (
|
|
|
|
"crypto/ecdsa"
|
2015-04-20 08:45:37 -07:00
|
|
|
"fmt"
|
2015-11-17 08:33:25 -08:00
|
|
|
"io/ioutil"
|
2015-05-09 03:00:51 -07:00
|
|
|
"math/big"
|
2015-03-09 15:00:27 -07:00
|
|
|
"os"
|
2017-03-06 01:37:32 -08:00
|
|
|
"os/user"
|
2015-05-12 05:24:11 -07:00
|
|
|
"path/filepath"
|
2015-05-12 06:20:53 -07:00
|
|
|
"runtime"
|
2015-07-07 01:32:05 -07:00
|
|
|
"strconv"
|
2015-11-17 08:33:25 -08:00
|
|
|
"strings"
|
2015-05-12 05:24:11 -07:00
|
|
|
|
2015-03-07 03:39:52 -08:00
|
|
|
"github.com/ethereum/go-ethereum/accounts"
|
2017-01-24 01:49:20 -08:00
|
|
|
"github.com/ethereum/go-ethereum/accounts/keystore"
|
2015-03-18 00:44:58 -07:00
|
|
|
"github.com/ethereum/go-ethereum/common"
|
2017-04-04 15:16:29 -07:00
|
|
|
"github.com/ethereum/go-ethereum/consensus/ethash"
|
2015-03-05 18:00:41 -08:00
|
|
|
"github.com/ethereum/go-ethereum/core"
|
2015-11-17 08:33:25 -08:00
|
|
|
"github.com/ethereum/go-ethereum/core/state"
|
2017-01-17 03:19:50 -08:00
|
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
2015-03-05 18:00:41 -08:00
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
"github.com/ethereum/go-ethereum/eth"
|
|
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
2016-11-25 07:55:06 -08:00
|
|
|
"github.com/ethereum/go-ethereum/ethstats"
|
2015-03-05 18:00:41 -08:00
|
|
|
"github.com/ethereum/go-ethereum/event"
|
2016-01-13 10:35:48 -08:00
|
|
|
"github.com/ethereum/go-ethereum/les"
|
2017-02-22 04:10:07 -08:00
|
|
|
"github.com/ethereum/go-ethereum/log"
|
2015-08-07 00:56:49 -07:00
|
|
|
"github.com/ethereum/go-ethereum/metrics"
|
2015-11-17 08:33:25 -08:00
|
|
|
"github.com/ethereum/go-ethereum/node"
|
|
|
|
"github.com/ethereum/go-ethereum/p2p/discover"
|
2016-11-09 06:35:04 -08:00
|
|
|
"github.com/ethereum/go-ethereum/p2p/discv5"
|
2015-03-05 18:00:41 -08:00
|
|
|
"github.com/ethereum/go-ethereum/p2p/nat"
|
2016-11-22 11:52:31 -08:00
|
|
|
"github.com/ethereum/go-ethereum/p2p/netutil"
|
2015-10-07 08:21:13 -07:00
|
|
|
"github.com/ethereum/go-ethereum/params"
|
2015-12-16 01:58:01 -08:00
|
|
|
"github.com/ethereum/go-ethereum/rpc"
|
2016-10-29 05:11:37 -07:00
|
|
|
whisper "github.com/ethereum/go-ethereum/whisper/whisperv2"
|
2016-06-09 02:44:42 -07:00
|
|
|
"gopkg.in/urfave/cli.v1"
|
2015-03-05 18:00:41 -08:00
|
|
|
)
|
|
|
|
|
2015-03-10 08:44:48 -07: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 14:51:50 -07:00
|
|
|
// NewApp creates an app with sane defaults.
|
2016-09-05 04:08:41 -07:00
|
|
|
func NewApp(gitCommit, usage string) *cli.App {
|
2015-03-09 14:51:50 -07:00
|
|
|
app := cli.NewApp()
|
2015-05-12 05:24:11 -07:00
|
|
|
app.Name = filepath.Base(os.Args[0])
|
2015-03-09 14:51:50 -07:00
|
|
|
app.Author = ""
|
2015-03-25 17:03:03 -07:00
|
|
|
//app.Authors = nil
|
2015-03-09 14:51:50 -07:00
|
|
|
app.Email = ""
|
2016-11-25 07:55:06 -08:00
|
|
|
app.Version = params.Version
|
2016-09-05 04:08:41 -07:00
|
|
|
if gitCommit != "" {
|
|
|
|
app.Version += "-" + gitCommit[:8]
|
|
|
|
}
|
2015-03-09 14:51:50 -07:00
|
|
|
app.Usage = usage
|
|
|
|
return app
|
|
|
|
}
|
|
|
|
|
2015-03-05 18:00:41 -08: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 06:43:55 -07:00
|
|
|
DataDirFlag = DirectoryFlag{
|
2015-03-05 18:00:41 -08:00
|
|
|
Name: "datadir",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Data directory for the databases and keystore",
|
2016-09-16 02:53:50 -07:00
|
|
|
Value: DirectoryString{node.DefaultDataDir()},
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2016-03-07 14:38:56 -08:00
|
|
|
KeyStoreDirFlag = DirectoryFlag{
|
|
|
|
Name: "keystore",
|
|
|
|
Usage: "Directory for the keystore (default = inside the datadir)",
|
|
|
|
}
|
2017-03-06 01:37:32 -08:00
|
|
|
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: 2,
|
|
|
|
}
|
|
|
|
EthashCachesOnDiskFlag = cli.IntFlag{
|
|
|
|
Name: "ethash.cachesondisk",
|
|
|
|
Usage: "Number of recent ethash caches to keep on disk (16MB each)",
|
|
|
|
Value: 3,
|
|
|
|
}
|
|
|
|
EthashDatasetDirFlag = DirectoryFlag{
|
|
|
|
Name: "ethash.dagdir",
|
|
|
|
Usage: "Directory to store the ethash mining DAGs (default = inside home folder)",
|
|
|
|
}
|
2017-03-06 07:20:25 -08:00
|
|
|
EthashDatasetsInMemoryFlag = cli.IntFlag{
|
|
|
|
Name: "ethash.dagsinmem",
|
|
|
|
Usage: "Number of recent ethash mining DAGs to keep in memory (1+GB each)",
|
|
|
|
Value: 1,
|
|
|
|
}
|
2017-03-06 01:37:32 -08:00
|
|
|
EthashDatasetsOnDiskFlag = cli.IntFlag{
|
|
|
|
Name: "ethash.dagsondisk",
|
2017-03-06 07:20:25 -08:00
|
|
|
Usage: "Number of recent ethash mining DAGs to keep on disk (1+GB each)",
|
2017-03-06 01:37:32 -08:00
|
|
|
Value: 2,
|
|
|
|
}
|
2015-03-18 00:44:58 -07:00
|
|
|
NetworkIdFlag = cli.IntFlag{
|
|
|
|
Name: "networkid",
|
2017-01-09 03:09:37 -08:00
|
|
|
Usage: "Network identifier (integer, 1=Frontier, 2=Morden (disused), 3=Ropsten)",
|
2015-03-18 00:44:58 -07:00
|
|
|
Value: eth.NetworkId,
|
|
|
|
}
|
2015-10-29 10:53:24 -07:00
|
|
|
TestNetFlag = cli.BoolFlag{
|
|
|
|
Name: "testnet",
|
2017-04-04 15:16:29 -07:00
|
|
|
Usage: "Ropsten network: pre-configured proof-of-work test network",
|
2015-07-10 05:29:40 -07:00
|
|
|
}
|
2015-09-06 06:46:54 -07:00
|
|
|
DevModeFlag = cli.BoolFlag{
|
|
|
|
Name: "dev",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Developer mode: pre-configured private network with several debugging flags",
|
2015-09-06 06:46:54 -07:00
|
|
|
}
|
2015-04-18 14:53:30 -07:00
|
|
|
IdentityFlag = cli.StringFlag{
|
|
|
|
Name: "identity",
|
2015-04-21 16:41:34 -07:00
|
|
|
Usage: "Custom node name",
|
2015-04-18 14:53:30 -07:00
|
|
|
}
|
2015-10-26 14:24:09 -07:00
|
|
|
DocRootFlag = DirectoryFlag{
|
|
|
|
Name: "docroot",
|
|
|
|
Usage: "Document Root for HTTPClient file scheme",
|
2016-09-16 02:53:50 -07:00
|
|
|
Value: DirectoryString{homeDir()},
|
2015-10-26 14:24:09 -07:00
|
|
|
}
|
2015-10-09 08:36:31 -07:00
|
|
|
FastSyncFlag = cli.BoolFlag{
|
|
|
|
Name: "fast",
|
2015-11-10 05:47:19 -08:00
|
|
|
Usage: "Enable fast syncing through state downloads",
|
2015-07-02 09:55:18 -07:00
|
|
|
}
|
2016-01-13 10:35:48 -08:00
|
|
|
LightModeFlag = cli.BoolFlag{
|
|
|
|
Name: "light",
|
|
|
|
Usage: "Enable light client mode",
|
|
|
|
}
|
|
|
|
LightServFlag = cli.IntFlag{
|
|
|
|
Name: "lightserv",
|
|
|
|
Usage: "Maximum percentage of time allowed for serving LES requests (0-90)",
|
|
|
|
Value: 0,
|
|
|
|
}
|
|
|
|
LightPeersFlag = cli.IntFlag{
|
|
|
|
Name: "lightpeers",
|
|
|
|
Usage: "Maximum number of LES client peers",
|
|
|
|
Value: 20,
|
|
|
|
}
|
2015-10-23 07:49:36 -07:00
|
|
|
LightKDFFlag = cli.BoolFlag{
|
|
|
|
Name: "lightkdf",
|
2015-11-10 05:47:19 -08:00
|
|
|
Usage: "Reduce key-derivation RAM & CPU usage at some expense of KDF strength",
|
2015-10-23 07:49:36 -07:00
|
|
|
}
|
2016-10-19 04:55:13 -07:00
|
|
|
// Performance tuning settings
|
|
|
|
CacheFlag = cli.IntFlag{
|
|
|
|
Name: "cache",
|
|
|
|
Usage: "Megabytes of memory allocated to internal caching (min 16MB / database forced)",
|
|
|
|
Value: 128,
|
|
|
|
}
|
|
|
|
TrieCacheGenFlag = cli.IntFlag{
|
|
|
|
Name: "trie-cache-gens",
|
|
|
|
Usage: "Number of trie node generations to keep in memory",
|
|
|
|
Value: int(state.MaxTrieCacheGen),
|
|
|
|
}
|
2015-10-29 10:53:24 -07:00
|
|
|
// Miner settings
|
|
|
|
MiningEnabledFlag = cli.BoolFlag{
|
|
|
|
Name: "mine",
|
|
|
|
Usage: "Enable mining",
|
2015-06-11 22:45:23 -07:00
|
|
|
}
|
2015-03-05 18:00:41 -08:00
|
|
|
MinerThreadsFlag = cli.IntFlag{
|
|
|
|
Name: "minerthreads",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Number of CPU threads to use for mining",
|
2015-03-05 18:00:41 -08:00
|
|
|
Value: runtime.NumCPU(),
|
|
|
|
}
|
common: move big integer math to common/math (#3699)
* common: remove CurrencyToString
Move denomination values to params instead.
* common: delete dead code
* common: move big integer operations to common/math
This commit consolidates all big integer operations into common/math and
adds tests and documentation.
There should be no change in semantics for BigPow, BigMin, BigMax, S256,
U256, Exp and their behaviour is now locked in by tests.
The BigD, BytesToBig and Bytes2Big functions don't provide additional
value, all uses are replaced by new(big.Int).SetBytes().
BigToBytes is now called PaddedBigBytes, its minimum output size
parameter is now specified as the number of bytes instead of bits. The
single use of this function is in the EVM's MSTORE instruction.
Big and String2Big are replaced by ParseBig, which is slightly stricter.
It previously accepted leading zeros for hexadecimal inputs but treated
decimal inputs as octal if a leading zero digit was present.
ParseUint64 is used in places where String2Big was used to decode a
uint64.
The new functions MustParseBig and MustParseUint64 are now used in many
places where parsing errors were previously ignored.
* common: delete unused big integer variables
* accounts/abi: replace uses of BytesToBig with use of encoding/binary
* common: remove BytesToBig
* common: remove Bytes2Big
* common: remove BigTrue
* cmd/utils: add BigFlag and use it for error-checked integer flags
While here, remove environment variable processing for DirectoryFlag
because we don't use it.
* core: add missing error checks in genesis block parser
* common: remove String2Big
* cmd/evm: use utils.BigFlag
* common/math: check for 256 bit overflow in ParseBig
This is supposed to prevent silent overflow/truncation of values in the
genesis block JSON. Without this check, a genesis block that set a
balance larger than 256 bits would lead to weird behaviour in the VM.
* cmd/utils: fixup import
2017-02-26 13:21:51 -08:00
|
|
|
TargetGasLimitFlag = cli.Uint64Flag{
|
2016-03-01 14:32:43 -08:00
|
|
|
Name: "targetgaslimit",
|
|
|
|
Usage: "Target gas limit sets the artificial target gas floor for the blocks to mine",
|
common: move big integer math to common/math (#3699)
* common: remove CurrencyToString
Move denomination values to params instead.
* common: delete dead code
* common: move big integer operations to common/math
This commit consolidates all big integer operations into common/math and
adds tests and documentation.
There should be no change in semantics for BigPow, BigMin, BigMax, S256,
U256, Exp and their behaviour is now locked in by tests.
The BigD, BytesToBig and Bytes2Big functions don't provide additional
value, all uses are replaced by new(big.Int).SetBytes().
BigToBytes is now called PaddedBigBytes, its minimum output size
parameter is now specified as the number of bytes instead of bits. The
single use of this function is in the EVM's MSTORE instruction.
Big and String2Big are replaced by ParseBig, which is slightly stricter.
It previously accepted leading zeros for hexadecimal inputs but treated
decimal inputs as octal if a leading zero digit was present.
ParseUint64 is used in places where String2Big was used to decode a
uint64.
The new functions MustParseBig and MustParseUint64 are now used in many
places where parsing errors were previously ignored.
* common: delete unused big integer variables
* accounts/abi: replace uses of BytesToBig with use of encoding/binary
* common: remove BytesToBig
* common: remove Bytes2Big
* common: remove BigTrue
* cmd/utils: add BigFlag and use it for error-checked integer flags
While here, remove environment variable processing for DirectoryFlag
because we don't use it.
* core: add missing error checks in genesis block parser
* common: remove String2Big
* cmd/evm: use utils.BigFlag
* common/math: check for 256 bit overflow in ParseBig
This is supposed to prevent silent overflow/truncation of values in the
genesis block JSON. Without this check, a genesis block that set a
balance larger than 256 bits would lead to weird behaviour in the VM.
* cmd/utils: fixup import
2017-02-26 13:21:51 -08:00
|
|
|
Value: params.GenesisGasLimit.Uint64(),
|
2016-03-01 14:32:43 -08:00
|
|
|
}
|
2015-03-26 14:49:22 -07:00
|
|
|
EtherbaseFlag = cli.StringFlag{
|
2015-03-27 04:14:00 -07:00
|
|
|
Name: "etherbase",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Public address for block mining rewards (default = first account created)",
|
2015-07-07 01:32:05 -07:00
|
|
|
Value: "0",
|
2015-03-26 14:49:22 -07:00
|
|
|
}
|
common: move big integer math to common/math (#3699)
* common: remove CurrencyToString
Move denomination values to params instead.
* common: delete dead code
* common: move big integer operations to common/math
This commit consolidates all big integer operations into common/math and
adds tests and documentation.
There should be no change in semantics for BigPow, BigMin, BigMax, S256,
U256, Exp and their behaviour is now locked in by tests.
The BigD, BytesToBig and Bytes2Big functions don't provide additional
value, all uses are replaced by new(big.Int).SetBytes().
BigToBytes is now called PaddedBigBytes, its minimum output size
parameter is now specified as the number of bytes instead of bits. The
single use of this function is in the EVM's MSTORE instruction.
Big and String2Big are replaced by ParseBig, which is slightly stricter.
It previously accepted leading zeros for hexadecimal inputs but treated
decimal inputs as octal if a leading zero digit was present.
ParseUint64 is used in places where String2Big was used to decode a
uint64.
The new functions MustParseBig and MustParseUint64 are now used in many
places where parsing errors were previously ignored.
* common: delete unused big integer variables
* accounts/abi: replace uses of BytesToBig with use of encoding/binary
* common: remove BytesToBig
* common: remove Bytes2Big
* common: remove BigTrue
* cmd/utils: add BigFlag and use it for error-checked integer flags
While here, remove environment variable processing for DirectoryFlag
because we don't use it.
* core: add missing error checks in genesis block parser
* common: remove String2Big
* cmd/evm: use utils.BigFlag
* common/math: check for 256 bit overflow in ParseBig
This is supposed to prevent silent overflow/truncation of values in the
genesis block JSON. Without this check, a genesis block that set a
balance larger than 256 bits would lead to weird behaviour in the VM.
* cmd/utils: fixup import
2017-02-26 13:21:51 -08:00
|
|
|
GasPriceFlag = BigFlag{
|
2015-05-09 03:00:51 -07:00
|
|
|
Name: "gasprice",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Minimal gas price to accept for mining a transactions",
|
common: move big integer math to common/math (#3699)
* common: remove CurrencyToString
Move denomination values to params instead.
* common: delete dead code
* common: move big integer operations to common/math
This commit consolidates all big integer operations into common/math and
adds tests and documentation.
There should be no change in semantics for BigPow, BigMin, BigMax, S256,
U256, Exp and their behaviour is now locked in by tests.
The BigD, BytesToBig and Bytes2Big functions don't provide additional
value, all uses are replaced by new(big.Int).SetBytes().
BigToBytes is now called PaddedBigBytes, its minimum output size
parameter is now specified as the number of bytes instead of bits. The
single use of this function is in the EVM's MSTORE instruction.
Big and String2Big are replaced by ParseBig, which is slightly stricter.
It previously accepted leading zeros for hexadecimal inputs but treated
decimal inputs as octal if a leading zero digit was present.
ParseUint64 is used in places where String2Big was used to decode a
uint64.
The new functions MustParseBig and MustParseUint64 are now used in many
places where parsing errors were previously ignored.
* common: delete unused big integer variables
* accounts/abi: replace uses of BytesToBig with use of encoding/binary
* common: remove BytesToBig
* common: remove Bytes2Big
* common: remove BigTrue
* cmd/utils: add BigFlag and use it for error-checked integer flags
While here, remove environment variable processing for DirectoryFlag
because we don't use it.
* core: add missing error checks in genesis block parser
* common: remove String2Big
* cmd/evm: use utils.BigFlag
* common/math: check for 256 bit overflow in ParseBig
This is supposed to prevent silent overflow/truncation of values in the
genesis block JSON. Without this check, a genesis block that set a
balance larger than 256 bits would lead to weird behaviour in the VM.
* cmd/utils: fixup import
2017-02-26 13:21:51 -08:00
|
|
|
Value: big.NewInt(20 * params.Shannon),
|
2015-05-09 03:00:51 -07:00
|
|
|
}
|
2015-09-22 01:34:58 -07:00
|
|
|
ExtraDataFlag = cli.StringFlag{
|
|
|
|
Name: "extradata",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Block extra data set by the miner (default = client version)",
|
2015-09-22 01:34:58 -07:00
|
|
|
}
|
2015-10-29 10:53:24 -07:00
|
|
|
// Account settings
|
2015-03-18 00:44:58 -07:00
|
|
|
UnlockedAccountFlag = cli.StringFlag{
|
|
|
|
Name: "unlock",
|
2015-11-17 08:33:25 -08:00
|
|
|
Usage: "Comma separated list of accounts to unlock",
|
2015-03-23 06:00:06 -07:00
|
|
|
Value: "",
|
|
|
|
}
|
|
|
|
PasswordFileFlag = cli.StringFlag{
|
|
|
|
Name: "password",
|
2015-11-17 08:33:25 -08:00
|
|
|
Usage: "Password file to use for non-inteactive password input",
|
2015-03-23 06:00:06 -07:00
|
|
|
Value: "",
|
2015-03-18 00:44:58 -07:00
|
|
|
}
|
2015-03-05 18:00:41 -08:00
|
|
|
|
2015-07-17 14:09:36 -07:00
|
|
|
VMForceJitFlag = cli.BoolFlag{
|
|
|
|
Name: "forcejit",
|
|
|
|
Usage: "Force the JIT VM to take precedence",
|
|
|
|
}
|
|
|
|
VMJitCacheFlag = cli.IntFlag{
|
|
|
|
Name: "jitcache",
|
|
|
|
Usage: "Amount of cached JIT VM programs",
|
|
|
|
Value: 64,
|
|
|
|
}
|
|
|
|
VMEnableJitFlag = cli.BoolFlag{
|
|
|
|
Name: "jitvm",
|
|
|
|
Usage: "Enable the JIT VM",
|
|
|
|
}
|
2017-01-17 03:19:50 -08:00
|
|
|
VMEnableDebugFlag = cli.BoolFlag{
|
|
|
|
Name: "vmdebug",
|
|
|
|
Usage: "Record information useful for VM and contract debugging",
|
|
|
|
}
|
2016-11-25 07:55:06 -08:00
|
|
|
// Logging and debug settings
|
|
|
|
EthStatsURLFlag = cli.StringFlag{
|
|
|
|
Name: "ethstats",
|
|
|
|
Usage: "Reporting URL of a ethstats service (nodename:secret@host:port)",
|
|
|
|
}
|
2015-06-29 06:11:01 -07:00
|
|
|
MetricsEnabledFlag = cli.BoolFlag{
|
|
|
|
Name: metrics.MetricsEnabledFlag,
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Enable metrics collection and reporting",
|
2015-06-29 06:11:01 -07:00
|
|
|
}
|
2016-04-21 02:14:57 -07:00
|
|
|
FakePoWFlag = cli.BoolFlag{
|
|
|
|
Name: "fakepow",
|
|
|
|
Usage: "Disables proof-of-work verification",
|
|
|
|
}
|
2017-03-08 03:26:19 -08:00
|
|
|
NoCompactionFlag = cli.BoolFlag{
|
|
|
|
Name: "nocompaction",
|
|
|
|
Usage: "Disables db compaction after import",
|
|
|
|
}
|
2015-03-05 18:00:41 -08:00
|
|
|
// RPC settings
|
|
|
|
RPCEnabledFlag = cli.BoolFlag{
|
|
|
|
Name: "rpc",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Enable the HTTP-RPC server",
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
|
|
|
RPCListenAddrFlag = cli.StringFlag{
|
|
|
|
Name: "rpcaddr",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "HTTP-RPC server listening interface",
|
2016-09-16 02:53:50 -07:00
|
|
|
Value: node.DefaultHTTPHost,
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
|
|
|
RPCPortFlag = cli.IntFlag{
|
|
|
|
Name: "rpcport",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "HTTP-RPC server listening port",
|
2016-09-16 02:53:50 -07:00
|
|
|
Value: node.DefaultHTTPPort,
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2015-03-29 12:21:14 -07:00
|
|
|
RPCCORSDomainFlag = cli.StringFlag{
|
|
|
|
Name: "rpccorsdomain",
|
2016-02-24 02:19:00 -08:00
|
|
|
Usage: "Comma separated list of domains from which to accept cross origin requests (browser enforced)",
|
2015-03-29 12:21:14 -07:00
|
|
|
Value: "",
|
|
|
|
}
|
2015-12-16 01:58:01 -08:00
|
|
|
RPCApiFlag = cli.StringFlag{
|
2015-06-16 04:30:53 -07:00
|
|
|
Name: "rpcapi",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "API's offered over the HTTP-RPC interface",
|
2016-02-09 03:24:42 -08:00
|
|
|
Value: rpc.DefaultHTTPApis,
|
2015-06-16 04:30:53 -07:00
|
|
|
}
|
2015-06-08 02:01:02 -07:00
|
|
|
IPCDisabledFlag = cli.BoolFlag{
|
|
|
|
Name: "ipcdisable",
|
|
|
|
Usage: "Disable the IPC-RPC server",
|
|
|
|
}
|
|
|
|
IPCApiFlag = cli.StringFlag{
|
|
|
|
Name: "ipcapi",
|
2016-09-16 02:53:50 -07:00
|
|
|
Usage: "APIs offered over the IPC-RPC interface",
|
2016-02-09 03:24:42 -08:00
|
|
|
Value: rpc.DefaultIPCApis,
|
2015-06-08 02:01:02 -07:00
|
|
|
}
|
|
|
|
IPCPathFlag = DirectoryFlag{
|
|
|
|
Name: "ipcpath",
|
2016-02-02 09:06:43 -08:00
|
|
|
Usage: "Filename for IPC socket/pipe within the datadir (explicit paths escape it)",
|
2016-09-16 02:53:50 -07:00
|
|
|
Value: DirectoryString{"geth.ipc"},
|
2015-06-08 02:01:02 -07:00
|
|
|
}
|
2015-12-16 01:58:01 -08:00
|
|
|
WSEnabledFlag = cli.BoolFlag{
|
2016-01-26 05:39:21 -08:00
|
|
|
Name: "ws",
|
2015-12-16 01:58:01 -08:00
|
|
|
Usage: "Enable the WS-RPC server",
|
|
|
|
}
|
|
|
|
WSListenAddrFlag = cli.StringFlag{
|
|
|
|
Name: "wsaddr",
|
|
|
|
Usage: "WS-RPC server listening interface",
|
2016-09-16 02:53:50 -07:00
|
|
|
Value: node.DefaultWSHost,
|
2015-12-16 01:58:01 -08:00
|
|
|
}
|
|
|
|
WSPortFlag = cli.IntFlag{
|
|
|
|
Name: "wsport",
|
|
|
|
Usage: "WS-RPC server listening port",
|
2016-09-16 02:53:50 -07:00
|
|
|
Value: node.DefaultWSPort,
|
2015-12-16 01:58:01 -08:00
|
|
|
}
|
|
|
|
WSApiFlag = cli.StringFlag{
|
|
|
|
Name: "wsapi",
|
|
|
|
Usage: "API's offered over the WS-RPC interface",
|
2016-02-09 03:24:42 -08:00
|
|
|
Value: rpc.DefaultHTTPApis,
|
2015-12-16 01:58:01 -08:00
|
|
|
}
|
2016-03-14 01:38:54 -07:00
|
|
|
WSAllowedOriginsFlag = cli.StringFlag{
|
|
|
|
Name: "wsorigins",
|
|
|
|
Usage: "Origins from which to accept websockets requests",
|
2015-12-16 01:58:01 -08:00
|
|
|
Value: "",
|
2015-10-15 07:07:19 -07:00
|
|
|
}
|
2015-06-19 05:04:18 -07:00
|
|
|
ExecFlag = cli.StringFlag{
|
|
|
|
Name: "exec",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Execute JavaScript statement (only in combination with console/attach)",
|
2015-06-19 05:04:18 -07:00
|
|
|
}
|
2016-05-06 02:40:23 -07:00
|
|
|
PreloadJSFlag = cli.StringFlag{
|
2016-04-07 04:48:24 -07:00
|
|
|
Name: "preload",
|
|
|
|
Usage: "Comma separated list of JavaScript files to preload into the console",
|
|
|
|
}
|
2016-01-26 05:39:21 -08:00
|
|
|
|
2015-03-05 18:00:41 -08:00
|
|
|
// Network Settings
|
|
|
|
MaxPeersFlag = cli.IntFlag{
|
|
|
|
Name: "maxpeers",
|
2015-04-21 16:41:34 -07:00
|
|
|
Usage: "Maximum number of network peers (network disabled if set to 0)",
|
2015-05-08 07:01:31 -07:00
|
|
|
Value: 25,
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2015-05-04 07:35:49 -07:00
|
|
|
MaxPendingPeersFlag = cli.IntFlag{
|
|
|
|
Name: "maxpendpeers",
|
|
|
|
Usage: "Maximum number of pending connection attempts (defaults used if set to 0)",
|
|
|
|
Value: 0,
|
|
|
|
}
|
2015-03-05 18:00:41 -08:00
|
|
|
ListenPortFlag = cli.IntFlag{
|
|
|
|
Name: "port",
|
|
|
|
Usage: "Network listening port",
|
|
|
|
Value: 30303,
|
|
|
|
}
|
2017-01-10 12:11:34 -08:00
|
|
|
BootnodesFlag = cli.StringFlag{
|
2015-03-05 18:00:41 -08:00
|
|
|
Name: "bootnodes",
|
2015-11-17 08:33:25 -08:00
|
|
|
Usage: "Comma separated enode URLs for P2P discovery bootstrap",
|
2017-01-10 12:11:34 -08:00
|
|
|
Value: "",
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
|
|
|
NodeKeyFileFlag = cli.StringFlag{
|
|
|
|
Name: "nodekey",
|
|
|
|
Usage: "P2P node key file",
|
|
|
|
}
|
|
|
|
NodeKeyHexFlag = cli.StringFlag{
|
|
|
|
Name: "nodekeyhex",
|
|
|
|
Usage: "P2P node key as hex (for testing)",
|
|
|
|
}
|
|
|
|
NATFlag = cli.StringFlag{
|
|
|
|
Name: "nat",
|
2015-04-21 16:41:34 -07:00
|
|
|
Usage: "NAT port mapping mechanism (any|none|upnp|pmp|extip:<IP>)",
|
2015-03-05 18:00:41 -08:00
|
|
|
Value: "any",
|
|
|
|
}
|
2015-05-26 09:07:24 -07:00
|
|
|
NoDiscoverFlag = cli.BoolFlag{
|
|
|
|
Name: "nodiscover",
|
|
|
|
Usage: "Disables the peer discovery mechanism (manual peer addition)",
|
|
|
|
}
|
2016-10-19 04:04:55 -07:00
|
|
|
DiscoveryV5Flag = cli.BoolFlag{
|
|
|
|
Name: "v5disc",
|
|
|
|
Usage: "Enables the experimental RLPx V5 (Topic Discovery) mechanism",
|
|
|
|
}
|
2016-11-22 11:52:31 -08:00
|
|
|
NetrestrictFlag = cli.StringFlag{
|
|
|
|
Name: "netrestrict",
|
|
|
|
Usage: "Restricts network communication to the given IP networks (CIDR masks)",
|
|
|
|
}
|
|
|
|
|
2015-04-20 08:45:37 -07:00
|
|
|
WhisperEnabledFlag = cli.BoolFlag{
|
|
|
|
Name: "shh",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Enable Whisper",
|
2015-04-20 08:45:37 -07:00
|
|
|
}
|
2016-11-22 11:52:31 -08:00
|
|
|
|
2015-04-22 15:11:11 -07:00
|
|
|
// ATM the url is left to the user and deployment to
|
2015-03-14 23:31:40 -07:00
|
|
|
JSpathFlag = cli.StringFlag{
|
|
|
|
Name: "jspath",
|
2016-11-25 03:31:06 -08:00
|
|
|
Usage: "JavaScript root path for `loadScript`",
|
2015-03-14 23:31:40 -07:00
|
|
|
Value: ".",
|
|
|
|
}
|
2015-04-22 15:11:11 -07:00
|
|
|
SolcPathFlag = cli.StringFlag{
|
|
|
|
Name: "solc",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Solidity compiler command to be used",
|
2015-04-22 15:11:11 -07:00
|
|
|
Value: "solc",
|
|
|
|
}
|
2015-10-29 10:53:24 -07:00
|
|
|
|
|
|
|
// Gas price oracle settings
|
2017-04-06 07:20:42 -07:00
|
|
|
GpoBlocksFlag = cli.IntFlag{
|
|
|
|
Name: "gpoblocks",
|
|
|
|
Usage: "Number of recent blocks to check for gas prices",
|
2015-05-26 05:17:43 -07:00
|
|
|
Value: 10,
|
|
|
|
}
|
2017-04-06 07:20:42 -07:00
|
|
|
GpoPercentileFlag = cli.IntFlag{
|
|
|
|
Name: "gpopercentile",
|
|
|
|
Usage: "Suggested gas price is the given percentile of a set of recent transaction gas prices",
|
|
|
|
Value: 50,
|
2015-05-26 05:17:43 -07:00
|
|
|
}
|
2015-03-05 18:00:41 -08:00
|
|
|
)
|
|
|
|
|
2016-08-18 04:28:17 -07:00
|
|
|
// MakeDataDir retrieves the currently requested data directory, terminating
|
2015-11-17 08:33:25 -08:00
|
|
|
// if none (or the empty string) is specified. If the node is starting a testnet,
|
|
|
|
// the a subdirectory of the specified datadir will be used.
|
2016-08-18 04:28:17 -07:00
|
|
|
func MakeDataDir(ctx *cli.Context) string {
|
2015-11-17 08:33:25 -08:00
|
|
|
if path := ctx.GlobalString(DataDirFlag.Name); path != "" {
|
2016-08-18 04:28:17 -07:00
|
|
|
// TODO: choose a different location outside of the regular datadir.
|
2015-11-17 08:33:25 -08:00
|
|
|
if ctx.GlobalBool(TestNetFlag.Name) {
|
2016-08-18 04:28:17 -07:00
|
|
|
return filepath.Join(path, "testnet")
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
|
|
|
return path
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2017-02-22 07:22:50 -08:00
|
|
|
Fatalf("Cannot determine default data directory, please set manually (--datadir)")
|
2015-11-17 08:33:25 -08:00
|
|
|
return ""
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
|
|
|
|
2017-03-06 01:37:32 -08:00
|
|
|
// MakeEthashCacheDir returns the directory to use for storing the ethash cache
|
|
|
|
// dumps.
|
|
|
|
func MakeEthashCacheDir(ctx *cli.Context) string {
|
|
|
|
if ctx.GlobalIsSet(EthashCacheDirFlag.Name) && ctx.GlobalString(EthashCacheDirFlag.Name) == "" {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
if !ctx.GlobalIsSet(EthashCacheDirFlag.Name) {
|
|
|
|
return "ethash"
|
|
|
|
}
|
|
|
|
return ctx.GlobalString(EthashCacheDirFlag.Name)
|
|
|
|
}
|
|
|
|
|
|
|
|
// MakeEthashDatasetDir returns the directory to use for storing the full ethash
|
|
|
|
// dataset dumps.
|
|
|
|
func MakeEthashDatasetDir(ctx *cli.Context) string {
|
|
|
|
if !ctx.GlobalIsSet(EthashDatasetDirFlag.Name) {
|
|
|
|
home := os.Getenv("HOME")
|
|
|
|
if home == "" {
|
|
|
|
if user, err := user.Current(); err == nil {
|
|
|
|
home = user.HomeDir
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if runtime.GOOS == "windows" {
|
|
|
|
return filepath.Join(home, "AppData", "Ethash")
|
|
|
|
}
|
|
|
|
return filepath.Join(home, ".ethash")
|
|
|
|
}
|
|
|
|
return ctx.GlobalString(EthashDatasetDirFlag.Name)
|
|
|
|
}
|
|
|
|
|
2016-02-09 03:24:42 -08:00
|
|
|
// MakeIPCPath creates an IPC path configuration from the set command line flags,
|
2016-02-02 09:06:43 -08:00
|
|
|
// returning an empty string if IPC was explicitly disabled, or the set path.
|
2016-02-09 03:24:42 -08:00
|
|
|
func MakeIPCPath(ctx *cli.Context) string {
|
2016-02-02 09:06:43 -08:00
|
|
|
if ctx.GlobalBool(IPCDisabledFlag.Name) {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return ctx.GlobalString(IPCPathFlag.Name)
|
|
|
|
}
|
|
|
|
|
2015-11-17 08:33:25 -08: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 18:00:41 -08:00
|
|
|
switch {
|
|
|
|
case file != "" && hex != "":
|
2017-02-22 07:22:50 -08:00
|
|
|
Fatalf("Options %q and %q are mutually exclusive", NodeKeyFileFlag.Name, NodeKeyHexFlag.Name)
|
2015-11-17 08:33:25 -08:00
|
|
|
|
2015-03-05 18:00:41 -08:00
|
|
|
case file != "":
|
|
|
|
if key, err = crypto.LoadECDSA(file); err != nil {
|
2017-02-22 07:22:50 -08:00
|
|
|
Fatalf("Option %q: %v", NodeKeyFileFlag.Name, err)
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2015-11-17 08:33:25 -08:00
|
|
|
|
2015-03-05 18:00:41 -08:00
|
|
|
case hex != "":
|
|
|
|
if key, err = crypto.HexToECDSA(hex); err != nil {
|
2017-02-22 07:22:50 -08:00
|
|
|
Fatalf("Option %q: %v", NodeKeyHexFlag.Name, err)
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return key
|
|
|
|
}
|
|
|
|
|
2016-08-18 04:28:17 -07:00
|
|
|
// makeNodeUserIdent creates the user identifier from CLI flags.
|
|
|
|
func makeNodeUserIdent(ctx *cli.Context) string {
|
|
|
|
var comps []string
|
2015-11-17 08:33:25 -08:00
|
|
|
if identity := ctx.GlobalString(IdentityFlag.Name); len(identity) > 0 {
|
2016-08-18 04:28:17 -07:00
|
|
|
comps = append(comps, identity)
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
|
|
|
if ctx.GlobalBool(VMEnableJitFlag.Name) {
|
2016-08-18 04:28:17 -07:00
|
|
|
comps = append(comps, "JIT")
|
2015-04-18 14:53:30 -07:00
|
|
|
}
|
2016-08-18 04:28:17 -07:00
|
|
|
return strings.Join(comps, "/")
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
// MakeBootstrapNodes creates a list of bootstrap nodes from the command line
|
|
|
|
// flags, reverting to pre-configured ones if none have been specified.
|
|
|
|
func MakeBootstrapNodes(ctx *cli.Context) []*discover.Node {
|
2017-01-05 04:56:06 -08:00
|
|
|
urls := params.MainnetBootnodes
|
|
|
|
if ctx.GlobalIsSet(BootnodesFlag.Name) {
|
2017-01-10 12:11:34 -08:00
|
|
|
urls = strings.Split(ctx.GlobalString(BootnodesFlag.Name), ",")
|
2017-01-05 04:56:06 -08:00
|
|
|
} else if ctx.GlobalBool(TestNetFlag.Name) {
|
|
|
|
urls = params.TestnetBootnodes
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
|
|
|
|
2017-01-05 04:56:06 -08:00
|
|
|
bootnodes := make([]*discover.Node, 0, len(urls))
|
|
|
|
for _, url := range urls {
|
2015-11-17 08:33:25 -08:00
|
|
|
node, err := discover.ParseNode(url)
|
|
|
|
if err != nil {
|
2017-03-02 05:06:16 -08:00
|
|
|
log.Error("Bootstrap URL invalid", "enode", url, "err", err)
|
2015-11-17 08:33:25 -08:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
bootnodes = append(bootnodes, node)
|
|
|
|
}
|
|
|
|
return bootnodes
|
|
|
|
}
|
|
|
|
|
2016-11-09 06:35:04 -08:00
|
|
|
// MakeBootstrapNodesV5 creates a list of bootstrap nodes from the command line
|
|
|
|
// flags, reverting to pre-configured ones if none have been specified.
|
|
|
|
func MakeBootstrapNodesV5(ctx *cli.Context) []*discv5.Node {
|
2017-01-05 04:56:06 -08:00
|
|
|
urls := params.DiscoveryV5Bootnodes
|
|
|
|
if ctx.GlobalIsSet(BootnodesFlag.Name) {
|
2017-01-10 12:11:34 -08:00
|
|
|
urls = strings.Split(ctx.GlobalString(BootnodesFlag.Name), ",")
|
2016-11-09 06:35:04 -08:00
|
|
|
}
|
|
|
|
|
2017-01-05 04:56:06 -08:00
|
|
|
bootnodes := make([]*discv5.Node, 0, len(urls))
|
|
|
|
for _, url := range urls {
|
2016-11-09 06:35:04 -08:00
|
|
|
node, err := discv5.ParseNode(url)
|
|
|
|
if err != nil {
|
2017-03-02 05:06:16 -08:00
|
|
|
log.Error("Bootstrap URL invalid", "enode", url, "err", err)
|
2016-11-09 06:35:04 -08:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
bootnodes = append(bootnodes, node)
|
|
|
|
}
|
|
|
|
return bootnodes
|
|
|
|
}
|
|
|
|
|
2015-11-17 08:33:25 -08:00
|
|
|
// MakeListenAddress creates a TCP listening address string from set command
|
|
|
|
// line flags.
|
|
|
|
func MakeListenAddress(ctx *cli.Context) string {
|
|
|
|
return fmt.Sprintf(":%d", ctx.GlobalInt(ListenPortFlag.Name))
|
|
|
|
}
|
|
|
|
|
2016-11-09 06:35:04 -08:00
|
|
|
// MakeDiscoveryV5Address creates a UDP listening address string from set command
|
|
|
|
// line flags for the V5 discovery protocol.
|
|
|
|
func MakeDiscoveryV5Address(ctx *cli.Context) string {
|
2016-10-19 04:04:55 -07:00
|
|
|
return fmt.Sprintf(":%d", ctx.GlobalInt(ListenPortFlag.Name)+1)
|
|
|
|
}
|
|
|
|
|
2015-11-17 08:33:25 -08:00
|
|
|
// MakeNAT creates a port mapper from set command line flags.
|
|
|
|
func MakeNAT(ctx *cli.Context) nat.Interface {
|
|
|
|
natif, err := nat.Parse(ctx.GlobalString(NATFlag.Name))
|
2015-07-07 03:53:36 -07:00
|
|
|
if err != nil {
|
2017-02-22 07:22:50 -08:00
|
|
|
Fatalf("Option %s: %v", NATFlag.Name, err)
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
|
|
|
return natif
|
|
|
|
}
|
|
|
|
|
2016-04-14 07:18:35 -07: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 03:24:42 -08:00
|
|
|
// MakeHTTPRpcHost creates the HTTP RPC listener interface string from the set
|
2016-02-05 03:45:36 -08:00
|
|
|
// command line flags, returning empty if the HTTP endpoint is disabled.
|
2016-02-09 03:24:42 -08:00
|
|
|
func MakeHTTPRpcHost(ctx *cli.Context) string {
|
2016-02-05 03:45:36 -08:00
|
|
|
if !ctx.GlobalBool(RPCEnabledFlag.Name) {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return ctx.GlobalString(RPCListenAddrFlag.Name)
|
|
|
|
}
|
|
|
|
|
2016-02-09 03:24:42 -08:00
|
|
|
// MakeWSRpcHost creates the WebSocket RPC listener interface string from the set
|
2016-02-05 05:08:48 -08:00
|
|
|
// command line flags, returning empty if the HTTP endpoint is disabled.
|
2016-02-09 03:24:42 -08:00
|
|
|
func MakeWSRpcHost(ctx *cli.Context) string {
|
2016-02-05 05:08:48 -08:00
|
|
|
if !ctx.GlobalBool(WSEnabledFlag.Name) {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return ctx.GlobalString(WSListenAddrFlag.Name)
|
|
|
|
}
|
|
|
|
|
2016-02-19 04:29:19 -08: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 {
|
2017-02-22 07:22:50 -08:00
|
|
|
Fatalf("Failed to raise file descriptor allowance: %v", err)
|
2016-02-19 04:29:19 -08:00
|
|
|
}
|
|
|
|
limit, err := getFdLimit()
|
|
|
|
if err != nil {
|
2017-02-22 07:22:50 -08:00
|
|
|
Fatalf("Failed to retrieve file descriptor allowance: %v", err)
|
2016-02-19 04:29:19 -08:00
|
|
|
}
|
|
|
|
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 08:33:25 -08:00
|
|
|
// MakeAddress converts an account specified directly as a hex encoded string or
|
|
|
|
// a key index in the key store to an internal account representation.
|
2017-01-24 01:49:20 -08:00
|
|
|
func MakeAddress(ks *keystore.KeyStore, account string) (accounts.Account, error) {
|
2015-11-17 08:33:25 -08:00
|
|
|
// If the specified account is a valid address, return it
|
|
|
|
if common.IsHexAddress(account) {
|
2016-03-02 16:09:16 -08:00
|
|
|
return accounts.Account{Address: common.HexToAddress(account)}, nil
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
|
|
|
// Otherwise try to interpret the account as a keystore index
|
|
|
|
index, err := strconv.Atoi(account)
|
2017-01-24 01:49:20 -08:00
|
|
|
if err != nil || index < 0 {
|
2016-03-02 16:09:16 -08:00
|
|
|
return accounts.Account{}, fmt.Errorf("invalid account address or index %q", account)
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
2017-01-24 01:49:20 -08:00
|
|
|
accs := ks.Accounts()
|
|
|
|
if len(accs) <= index {
|
|
|
|
return accounts.Account{}, fmt.Errorf("index %d higher than number of accounts %d", index, len(accs))
|
|
|
|
}
|
|
|
|
return accs[index], nil
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
// MakeEtherbase retrieves the etherbase either from the directly specified
|
|
|
|
// command line flags or from the keystore if CLI indexed.
|
2017-01-24 01:49:20 -08:00
|
|
|
func MakeEtherbase(ks *keystore.KeyStore, ctx *cli.Context) common.Address {
|
|
|
|
accounts := ks.Accounts()
|
2015-12-01 02:20:49 -08:00
|
|
|
if !ctx.GlobalIsSet(EtherbaseFlag.Name) && len(accounts) == 0 {
|
2017-03-02 05:06:16 -08:00
|
|
|
log.Warn("No etherbase set and no accounts found as default")
|
2015-11-17 08:33:25 -08:00
|
|
|
return common.Address{}
|
|
|
|
}
|
2015-12-01 02:20:49 -08:00
|
|
|
etherbase := ctx.GlobalString(EtherbaseFlag.Name)
|
|
|
|
if etherbase == "" {
|
|
|
|
return common.Address{}
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
2015-12-01 02:20:49 -08:00
|
|
|
// If the specified etherbase is a valid address, return it
|
2017-01-24 01:49:20 -08:00
|
|
|
account, err := MakeAddress(ks, etherbase)
|
2015-11-17 08:33:25 -08:00
|
|
|
if err != nil {
|
2017-02-22 07:22:50 -08:00
|
|
|
Fatalf("Option %q: %v", EtherbaseFlag.Name, err)
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
2016-03-02 16:09:16 -08:00
|
|
|
return account.Address
|
2015-11-17 08:33:25 -08: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 03:53:36 -07:00
|
|
|
}
|
2015-11-17 08:33:25 -08:00
|
|
|
return extra
|
|
|
|
}
|
|
|
|
|
2016-03-30 14:20:06 -07:00
|
|
|
// MakePasswordList reads password lines from the file specified by --password.
|
2015-11-17 08:33:25 -08:00
|
|
|
func MakePasswordList(ctx *cli.Context) []string {
|
2016-03-30 14:20:06 -07:00
|
|
|
path := ctx.GlobalString(PasswordFileFlag.Name)
|
|
|
|
if path == "" {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
text, err := ioutil.ReadFile(path)
|
|
|
|
if err != nil {
|
2017-02-22 07:22:50 -08:00
|
|
|
Fatalf("Failed to read password file: %v", err)
|
2016-03-30 14:20:06 -07:00
|
|
|
}
|
|
|
|
lines := strings.Split(string(text), "\n")
|
|
|
|
// Sanitise DOS line endings.
|
|
|
|
for i := range lines {
|
|
|
|
lines[i] = strings.TrimRight(lines[i], "\r")
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
2016-03-30 14:20:06 -07:00
|
|
|
return lines
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
|
|
|
|
2016-08-15 09:38:32 -07:00
|
|
|
// MakeNode configures a node with no services from command line flags.
|
2016-09-05 04:08:41 -07:00
|
|
|
func MakeNode(ctx *cli.Context, name, gitCommit string) *node.Node {
|
2016-11-25 07:55:06 -08:00
|
|
|
vsn := params.Version
|
2016-09-05 04:08:41 -07:00
|
|
|
if gitCommit != "" {
|
|
|
|
vsn += "-" + gitCommit[:8]
|
|
|
|
}
|
|
|
|
|
2017-01-25 17:52:59 -08:00
|
|
|
// if we're running a light client or server, force enable the v5 peer discovery unless it is explicitly disabled with --nodiscover
|
|
|
|
// note that explicitly specifying --v5disc overrides --nodiscover, in which case the later only disables v4 discovery
|
|
|
|
forceV5Discovery := (ctx.GlobalBool(LightModeFlag.Name) || ctx.GlobalInt(LightServFlag.Name) > 0) && !ctx.GlobalBool(NoDiscoverFlag.Name)
|
|
|
|
|
2016-08-15 09:38:32 -07:00
|
|
|
config := &node.Config{
|
2016-08-18 04:28:17 -07:00
|
|
|
DataDir: MakeDataDir(ctx),
|
2016-08-15 09:38:32 -07:00
|
|
|
KeyStoreDir: ctx.GlobalString(KeyStoreDirFlag.Name),
|
|
|
|
UseLightweightKDF: ctx.GlobalBool(LightKDFFlag.Name),
|
|
|
|
PrivateKey: MakeNodeKey(ctx),
|
2016-08-18 04:28:17 -07:00
|
|
|
Name: name,
|
|
|
|
Version: vsn,
|
|
|
|
UserIdent: makeNodeUserIdent(ctx),
|
2017-01-25 17:52:59 -08:00
|
|
|
NoDiscovery: ctx.GlobalBool(NoDiscoverFlag.Name) || ctx.GlobalBool(LightModeFlag.Name), // always disable v4 discovery in light client mode
|
|
|
|
DiscoveryV5: ctx.GlobalBool(DiscoveryV5Flag.Name) || forceV5Discovery,
|
2016-11-09 06:35:04 -08:00
|
|
|
DiscoveryV5Addr: MakeDiscoveryV5Address(ctx),
|
2016-08-15 09:38:32 -07:00
|
|
|
BootstrapNodes: MakeBootstrapNodes(ctx),
|
2016-11-09 06:35:04 -08:00
|
|
|
BootstrapNodesV5: MakeBootstrapNodesV5(ctx),
|
2016-08-15 09:38:32 -07:00
|
|
|
ListenAddr: MakeListenAddress(ctx),
|
|
|
|
NAT: MakeNAT(ctx),
|
|
|
|
MaxPeers: ctx.GlobalInt(MaxPeersFlag.Name),
|
|
|
|
MaxPendingPeers: ctx.GlobalInt(MaxPendingPeersFlag.Name),
|
|
|
|
IPCPath: MakeIPCPath(ctx),
|
|
|
|
HTTPHost: MakeHTTPRpcHost(ctx),
|
|
|
|
HTTPPort: ctx.GlobalInt(RPCPortFlag.Name),
|
|
|
|
HTTPCors: ctx.GlobalString(RPCCORSDomainFlag.Name),
|
|
|
|
HTTPModules: MakeRPCModules(ctx.GlobalString(RPCApiFlag.Name)),
|
|
|
|
WSHost: MakeWSRpcHost(ctx),
|
|
|
|
WSPort: ctx.GlobalInt(WSPortFlag.Name),
|
|
|
|
WSOrigins: ctx.GlobalString(WSAllowedOriginsFlag.Name),
|
|
|
|
WSModules: MakeRPCModules(ctx.GlobalString(WSApiFlag.Name)),
|
|
|
|
}
|
|
|
|
if ctx.GlobalBool(DevModeFlag.Name) {
|
|
|
|
if !ctx.GlobalIsSet(DataDirFlag.Name) {
|
|
|
|
config.DataDir = filepath.Join(os.TempDir(), "/ethereum_dev_mode")
|
|
|
|
}
|
|
|
|
// --dev mode does not need p2p networking.
|
|
|
|
config.MaxPeers = 0
|
|
|
|
config.ListenAddr = ":0"
|
|
|
|
}
|
2016-11-22 11:52:31 -08:00
|
|
|
if netrestrict := ctx.GlobalString(NetrestrictFlag.Name); netrestrict != "" {
|
|
|
|
list, err := netutil.ParseNetlist(netrestrict)
|
|
|
|
if err != nil {
|
2017-02-22 07:22:50 -08:00
|
|
|
Fatalf("Option %q: %v", NetrestrictFlag.Name, err)
|
2016-11-22 11:52:31 -08:00
|
|
|
}
|
|
|
|
config.NetRestrict = list
|
|
|
|
}
|
|
|
|
|
2016-08-15 09:38:32 -07:00
|
|
|
stack, err := node.New(config)
|
|
|
|
if err != nil {
|
2017-02-22 07:22:50 -08:00
|
|
|
Fatalf("Failed to create the protocol stack: %v", err)
|
2016-08-15 09:38:32 -07:00
|
|
|
}
|
|
|
|
return stack
|
|
|
|
}
|
|
|
|
|
|
|
|
// RegisterEthService configures eth.Ethereum from command line flags and adds it to the
|
|
|
|
// given node.
|
2016-09-05 04:08:41 -07:00
|
|
|
func RegisterEthService(ctx *cli.Context, stack *node.Node, extra []byte) {
|
2015-11-17 08:33:25 -08:00
|
|
|
// Avoid conflicting network flags
|
2017-01-09 03:09:37 -08:00
|
|
|
networks, netFlags := 0, []cli.BoolFlag{DevModeFlag, TestNetFlag}
|
2015-11-17 08:33:25 -08:00
|
|
|
for _, flag := range netFlags {
|
|
|
|
if ctx.GlobalBool(flag.Name) {
|
|
|
|
networks++
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if networks > 1 {
|
2017-02-22 07:22:50 -08:00
|
|
|
Fatalf("The %v flags are mutually exclusive", netFlags)
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
2017-02-07 02:47:34 -08:00
|
|
|
ks := stack.AccountManager().Backends(keystore.KeyStoreType)[0].(*keystore.KeyStore)
|
2015-11-17 08:33:25 -08:00
|
|
|
|
|
|
|
ethConf := ð.Config{
|
2017-01-24 01:49:20 -08:00
|
|
|
Etherbase: MakeEtherbase(ks, ctx),
|
2015-10-09 08:36:31 -07:00
|
|
|
FastSync: ctx.GlobalBool(FastSyncFlag.Name),
|
2016-01-13 10:35:48 -08:00
|
|
|
LightMode: ctx.GlobalBool(LightModeFlag.Name),
|
|
|
|
LightServ: ctx.GlobalInt(LightServFlag.Name),
|
|
|
|
LightPeers: ctx.GlobalInt(LightPeersFlag.Name),
|
|
|
|
MaxPeers: ctx.GlobalInt(MaxPeersFlag.Name),
|
2015-07-22 03:46:20 -07:00
|
|
|
DatabaseCache: ctx.GlobalInt(CacheFlag.Name),
|
2016-02-19 04:29:19 -08:00
|
|
|
DatabaseHandles: MakeDatabaseHandles(),
|
2015-05-26 05:17:43 -07:00
|
|
|
NetworkId: ctx.GlobalInt(NetworkIdFlag.Name),
|
|
|
|
MinerThreads: ctx.GlobalInt(MinerThreadsFlag.Name),
|
2015-11-17 08:33:25 -08:00
|
|
|
ExtraData: MakeMinerExtra(extra, ctx),
|
2015-10-26 14:24:09 -07:00
|
|
|
DocRoot: ctx.GlobalString(DocRootFlag.Name),
|
common: move big integer math to common/math (#3699)
* common: remove CurrencyToString
Move denomination values to params instead.
* common: delete dead code
* common: move big integer operations to common/math
This commit consolidates all big integer operations into common/math and
adds tests and documentation.
There should be no change in semantics for BigPow, BigMin, BigMax, S256,
U256, Exp and their behaviour is now locked in by tests.
The BigD, BytesToBig and Bytes2Big functions don't provide additional
value, all uses are replaced by new(big.Int).SetBytes().
BigToBytes is now called PaddedBigBytes, its minimum output size
parameter is now specified as the number of bytes instead of bits. The
single use of this function is in the EVM's MSTORE instruction.
Big and String2Big are replaced by ParseBig, which is slightly stricter.
It previously accepted leading zeros for hexadecimal inputs but treated
decimal inputs as octal if a leading zero digit was present.
ParseUint64 is used in places where String2Big was used to decode a
uint64.
The new functions MustParseBig and MustParseUint64 are now used in many
places where parsing errors were previously ignored.
* common: delete unused big integer variables
* accounts/abi: replace uses of BytesToBig with use of encoding/binary
* common: remove BytesToBig
* common: remove Bytes2Big
* common: remove BigTrue
* cmd/utils: add BigFlag and use it for error-checked integer flags
While here, remove environment variable processing for DirectoryFlag
because we don't use it.
* core: add missing error checks in genesis block parser
* common: remove String2Big
* cmd/evm: use utils.BigFlag
* common/math: check for 256 bit overflow in ParseBig
This is supposed to prevent silent overflow/truncation of values in the
genesis block JSON. Without this check, a genesis block that set a
balance larger than 256 bits would lead to weird behaviour in the VM.
* cmd/utils: fixup import
2017-02-26 13:21:51 -08:00
|
|
|
GasPrice: GlobalBig(ctx, GasPriceFlag.Name),
|
2017-04-06 07:20:42 -07:00
|
|
|
GpoBlocks: ctx.GlobalInt(GpoBlocksFlag.Name),
|
|
|
|
GpoPercentile: ctx.GlobalInt(GpoPercentileFlag.Name),
|
2015-05-26 05:17:43 -07:00
|
|
|
SolcPath: ctx.GlobalString(SolcPathFlag.Name),
|
2017-03-06 01:37:32 -08:00
|
|
|
EthashCacheDir: MakeEthashCacheDir(ctx),
|
|
|
|
EthashCachesInMem: ctx.GlobalInt(EthashCachesInMemoryFlag.Name),
|
|
|
|
EthashCachesOnDisk: ctx.GlobalInt(EthashCachesOnDiskFlag.Name),
|
|
|
|
EthashDatasetDir: MakeEthashDatasetDir(ctx),
|
2017-03-06 07:20:25 -08:00
|
|
|
EthashDatasetsInMem: ctx.GlobalInt(EthashDatasetsInMemoryFlag.Name),
|
2017-03-06 01:37:32 -08:00
|
|
|
EthashDatasetsOnDisk: ctx.GlobalInt(EthashDatasetsOnDiskFlag.Name),
|
2017-01-17 03:19:50 -08:00
|
|
|
EnablePreimageRecording: ctx.GlobalBool(VMEnableDebugFlag.Name),
|
2015-03-13 10:30:45 -07:00
|
|
|
}
|
2015-09-06 06:46:54 -07:00
|
|
|
|
2015-11-17 08:33:25 -08:00
|
|
|
// Override any default configs in dev mode or the test net
|
|
|
|
switch {
|
|
|
|
case ctx.GlobalBool(TestNetFlag.Name):
|
|
|
|
if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
|
2016-11-20 13:32:31 -08:00
|
|
|
ethConf.NetworkId = 3
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
2016-11-20 13:32:31 -08:00
|
|
|
ethConf.Genesis = core.DefaultTestnetGenesisBlock()
|
2015-11-17 08:33:25 -08:00
|
|
|
case ctx.GlobalBool(DevModeFlag.Name):
|
2017-01-09 03:09:37 -08:00
|
|
|
ethConf.Genesis = core.DevGenesisBlock()
|
2015-11-17 08:33:25 -08:00
|
|
|
if !ctx.GlobalIsSet(GasPriceFlag.Name) {
|
|
|
|
ethConf.GasPrice = new(big.Int)
|
2015-09-06 06:46:54 -07:00
|
|
|
}
|
2015-11-17 08:33:25 -08:00
|
|
|
ethConf.PowTest = true
|
2015-09-06 06:46:54 -07:00
|
|
|
}
|
2016-10-19 04:55:13 -07:00
|
|
|
// Override any global options pertaining to the Ethereum protocol
|
|
|
|
if gen := ctx.GlobalInt(TrieCacheGenFlag.Name); gen > 0 {
|
|
|
|
state.MaxTrieCacheGen = uint16(gen)
|
|
|
|
}
|
2015-12-15 19:26:23 -08:00
|
|
|
|
2016-01-13 10:35:48 -08:00
|
|
|
if ethConf.LightMode {
|
|
|
|
if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
|
|
|
|
return les.New(ctx, ethConf)
|
|
|
|
}); err != nil {
|
2017-02-22 07:22:50 -08:00
|
|
|
Fatalf("Failed to register the Ethereum light node service: %v", err)
|
2016-01-13 10:35:48 -08:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
|
|
|
|
fullNode, err := eth.New(ctx, ethConf)
|
|
|
|
if fullNode != nil && ethConf.LightServ > 0 {
|
|
|
|
ls, _ := les.NewLesServer(fullNode, ethConf)
|
|
|
|
fullNode.AddLesServer(ls)
|
|
|
|
}
|
|
|
|
return fullNode, err
|
|
|
|
}); err != nil {
|
2017-02-22 07:22:50 -08:00
|
|
|
Fatalf("Failed to register the Ethereum full node service: %v", err)
|
2016-01-13 10:35:48 -08:00
|
|
|
}
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
2016-08-15 09:38:32 -07:00
|
|
|
}
|
|
|
|
|
2016-11-25 07:55:06 -08:00
|
|
|
// RegisterShhService configures Whisper and adds it to the given node.
|
2016-08-15 09:38:32 -07:00
|
|
|
func RegisterShhService(stack *node.Node) {
|
|
|
|
if err := stack.Register(func(*node.ServiceContext) (node.Service, error) { return whisper.New(), nil }); err != nil {
|
2017-02-22 07:22:50 -08:00
|
|
|
Fatalf("Failed to register the Whisper service: %v", err)
|
2016-08-15 09:38:32 -07:00
|
|
|
}
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
|
|
|
|
2016-11-25 07:55:06 -08:00
|
|
|
// RegisterEthStatsService configures the Ethereum Stats daemon and adds it to
|
|
|
|
// th egiven node.
|
|
|
|
func RegisterEthStatsService(stack *node.Node, url string) {
|
|
|
|
if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
|
|
|
|
// Retrieve both eth and les services
|
|
|
|
var ethServ *eth.Ethereum
|
|
|
|
ctx.Service(ðServ)
|
|
|
|
|
|
|
|
var lesServ *les.LightEthereum
|
|
|
|
ctx.Service(&lesServ)
|
|
|
|
|
|
|
|
return ethstats.New(url, ethServ, lesServ)
|
|
|
|
}); err != nil {
|
2017-02-22 07:22:50 -08:00
|
|
|
Fatalf("Failed to register the Ethereum Stats service: %v", err)
|
2016-11-25 07:55:06 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-07 08:21:13 -07:00
|
|
|
// SetupNetwork configures the system for either the main net or some test network.
|
|
|
|
func SetupNetwork(ctx *cli.Context) {
|
common: move big integer math to common/math (#3699)
* common: remove CurrencyToString
Move denomination values to params instead.
* common: delete dead code
* common: move big integer operations to common/math
This commit consolidates all big integer operations into common/math and
adds tests and documentation.
There should be no change in semantics for BigPow, BigMin, BigMax, S256,
U256, Exp and their behaviour is now locked in by tests.
The BigD, BytesToBig and Bytes2Big functions don't provide additional
value, all uses are replaced by new(big.Int).SetBytes().
BigToBytes is now called PaddedBigBytes, its minimum output size
parameter is now specified as the number of bytes instead of bits. The
single use of this function is in the EVM's MSTORE instruction.
Big and String2Big are replaced by ParseBig, which is slightly stricter.
It previously accepted leading zeros for hexadecimal inputs but treated
decimal inputs as octal if a leading zero digit was present.
ParseUint64 is used in places where String2Big was used to decode a
uint64.
The new functions MustParseBig and MustParseUint64 are now used in many
places where parsing errors were previously ignored.
* common: delete unused big integer variables
* accounts/abi: replace uses of BytesToBig with use of encoding/binary
* common: remove BytesToBig
* common: remove Bytes2Big
* common: remove BigTrue
* cmd/utils: add BigFlag and use it for error-checked integer flags
While here, remove environment variable processing for DirectoryFlag
because we don't use it.
* core: add missing error checks in genesis block parser
* common: remove String2Big
* cmd/evm: use utils.BigFlag
* common/math: check for 256 bit overflow in ParseBig
This is supposed to prevent silent overflow/truncation of values in the
genesis block JSON. Without this check, a genesis block that set a
balance larger than 256 bits would lead to weird behaviour in the VM.
* cmd/utils: fixup import
2017-02-26 13:21:51 -08:00
|
|
|
params.TargetGasLimit = new(big.Int).SetUint64(ctx.GlobalUint64(TargetGasLimitFlag.Name))
|
2015-10-07 08:21:13 -07:00
|
|
|
}
|
|
|
|
|
2016-01-13 10:35:48 -08:00
|
|
|
func ChainDbName(ctx *cli.Context) string {
|
|
|
|
if ctx.GlobalBool(LightModeFlag.Name) {
|
|
|
|
return "lightchaindata"
|
|
|
|
} else {
|
|
|
|
return "chaindata"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-01 14:32:43 -08:00
|
|
|
// MakeChainDatabase open an LevelDB using the flags passed to the client and will hard crash if it fails.
|
2016-08-18 04:28:17 -07:00
|
|
|
func MakeChainDatabase(ctx *cli.Context, stack *node.Node) ethdb.Database {
|
2016-03-01 14:32:43 -08:00
|
|
|
var (
|
|
|
|
cache = ctx.GlobalInt(CacheFlag.Name)
|
|
|
|
handles = MakeDatabaseHandles()
|
2016-01-13 10:35:48 -08:00
|
|
|
name = ChainDbName(ctx)
|
2016-03-01 14:32:43 -08:00
|
|
|
)
|
2015-07-22 03:46:20 -07:00
|
|
|
|
2016-01-13 10:35:48 -08:00
|
|
|
chainDb, err := stack.OpenDatabase(name, cache, handles)
|
2016-03-01 14:32:43 -08:00
|
|
|
if err != nil {
|
2017-02-22 07:22:50 -08:00
|
|
|
Fatalf("Could not open database: %v", err)
|
2015-04-13 01:13:52 -07:00
|
|
|
}
|
2016-03-01 14:32:43 -08:00
|
|
|
return chainDb
|
|
|
|
}
|
|
|
|
|
2017-03-02 05:03:33 -08:00
|
|
|
func MakeGenesis(ctx *cli.Context) *core.Genesis {
|
|
|
|
var genesis *core.Genesis
|
|
|
|
switch {
|
|
|
|
case ctx.GlobalBool(TestNetFlag.Name):
|
|
|
|
genesis = core.DefaultTestnetGenesisBlock()
|
|
|
|
case ctx.GlobalBool(DevModeFlag.Name):
|
|
|
|
genesis = core.DevGenesisBlock()
|
|
|
|
}
|
|
|
|
return genesis
|
|
|
|
}
|
|
|
|
|
2016-03-01 14:32:43 -08:00
|
|
|
// MakeChain creates a chain manager from set command line flags.
|
2016-08-18 04:28:17 -07:00
|
|
|
func MakeChain(ctx *cli.Context, stack *node.Node) (chain *core.BlockChain, chainDb ethdb.Database) {
|
2016-03-01 14:32:43 -08:00
|
|
|
var err error
|
2016-08-18 04:28:17 -07:00
|
|
|
chainDb = MakeChainDatabase(ctx, stack)
|
2016-03-01 14:32:43 -08:00
|
|
|
|
2017-04-04 15:16:29 -07:00
|
|
|
engine := ethash.NewFaker()
|
2016-04-21 02:14:57 -07:00
|
|
|
if !ctx.GlobalBool(FakePoWFlag.Name) {
|
2017-04-04 15:16:29 -07:00
|
|
|
engine = ethash.New("", 1, 0, "", 1, 0)
|
2016-04-21 02:14:57 -07:00
|
|
|
}
|
2017-03-02 05:03:33 -08:00
|
|
|
config, _, err := core.SetupGenesisBlock(chainDb, MakeGenesis(ctx))
|
|
|
|
if err != nil {
|
|
|
|
Fatalf("%v", err)
|
|
|
|
}
|
|
|
|
vmcfg := vm.Config{EnablePreimageRecording: ctx.GlobalBool(VMEnableDebugFlag.Name)}
|
2017-04-04 15:16:29 -07:00
|
|
|
chain, err = core.NewBlockChain(chainDb, config, engine, new(event.TypeMux), vmcfg)
|
2015-06-08 03:12:13 -07:00
|
|
|
if err != nil {
|
2017-03-02 05:03:33 -08:00
|
|
|
Fatalf("Can't create BlockChain: %v", err)
|
2015-06-08 03:12:13 -07:00
|
|
|
}
|
2015-08-06 10:57:39 -07:00
|
|
|
return chain, chainDb
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2016-05-06 02:40:23 -07: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
|
|
|
|
}
|