utils

package
v1.10.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 6, 2023 License: GPL-3.0 Imports: 63 Imported by: 53

Documentation

Overview

Package utils contains internal helper functions for klaytn commands.

utils package provides various helper functions especially for handling various commands and options.

Source Files

Each file contains the following contents

  • app.go : Provides NewCLI() function but it is not being used.
  • cmd.go : Provide import/export chain functions but it is not being used.
  • customflags.go : Provides `DirectoryString`, `DirectoryFlags` and marshaling functions to support custom flags
  • files.go : Provides `WriteFile` function to store contents in a given file
  • flags.go : Defines various flags which can be used in running a node
  • flaggroup.go : Categorizes flags into groups to print structured help descriptions.
  • helptemplate.go : Provides a template for help contents which explains option names and its usages
  • strings.go : Provides helper functions to handle string manipulations
  • testcmd.go : Provides test functions to test command arguments
  • usage.go : Provides help printer which prints help contents neatly

Index

Constants

View Source 
const (
	ClientIdentifier = "klay" // Client identifier to advertise over the network
	SCNNetworkType   = "scn"  // Service Chain Network
	MNNetworkType    = "mn"   // Mainnet Network

)

Variables

View Source 
var (
	// General settings
	ConfFlag = cli.StringFlag{
		Name: "conf",
	}
	NtpDisableFlag = cli.BoolFlag{
		Name:   "ntp.disable",
		Usage:  "Disable checking if the local time is synchronized with ntp server. If this flag is not set, the local time is checked with the time of the server specified by ntp.server.",
		EnvVar: "KLAYTN_NTP_DISABLE",
	}
	NtpServerFlag = cli.StringFlag{
		Name:   "ntp.server",
		Usage:  "Remote ntp server:port to get the time",
		Value:  "pool.ntp.org:123",
		EnvVar: "KLAYTN_NTP_SERVER",
	}
	NetworkTypeFlag = cli.StringFlag{
		Name:   "networktype",
		Usage:  "Klaytn network type (main-net (mn), service chain-net (scn))",
		Value:  "mn",
		EnvVar: "KLAYTN_NETWORKTYPE",
	}
	DbTypeFlag = cli.StringFlag{
		Name:   "dbtype",
		Usage:  `Blockchain storage database type ("LevelDB", "BadgerDB", "MemoryDB", "DynamoDBS3")`,
		Value:  "LevelDB",
		EnvVar: "KLAYTN_DBTYPE",
	}
	SrvTypeFlag = cli.StringFlag{
		Name:   "srvtype",
		Usage:  `json rpc server type ("http", "fasthttp")`,
		Value:  "fasthttp",
		EnvVar: "KLAYTN_SRVTYPE",
	}
	DataDirFlag = DirectoryFlag{
		Name:   "datadir",
		Value:  DirectoryString{node.DefaultDataDir()},
		Usage:  "Data directory for the databases and keystore. This value is only used in local DB.",
		EnvVar: "KLAYTN_DATADIR",
	}
	KeyStoreDirFlag = DirectoryFlag{
		Name:   "keystore",
		Usage:  "Directory for the keystore (default = inside the datadir)",
		EnvVar: "KLAYTN_KEYSTORE",
	}
	// TODO-Klaytn-Bootnode: redefine networkid
	NetworkIdFlag = cli.Uint64Flag{
		Name:   "networkid",
		Usage:  "Network identifier (integer, 8217=Cypress (Mainnet) , 1000=Aspen, 1001=Baobab)",
		Value:  cn.GetDefaultConfig().NetworkId,
		EnvVar: "KLAYTN_NETWORKID",
	}
	IdentityFlag = cli.StringFlag{
		Name:   "identity",
		Usage:  "Custom node name",
		EnvVar: "KLAYTN_IDENTITY",
	}
	DocRootFlag = DirectoryFlag{
		Name:   "docroot",
		Usage:  "Document Root for HTTPClient file scheme",
		Value:  DirectoryString{homeDir()},
		EnvVar: "KLAYTN_DOCROOT",
	}

	SyncModeFlag = TextMarshalerFlag{
		Name:   "syncmode",
		Usage:  `Blockchain sync mode ("full" or "snap")`,
		Value:  &defaultSyncMode,
		EnvVar: "KLAYTN_SYNCMODE",
	}
	GCModeFlag = cli.StringFlag{
		Name:   "gcmode",
		Usage:  `Blockchain garbage collection mode ("full", "archive")`,
		Value:  "full",
		EnvVar: "KLAYTN_GCMODE",
	}
	LightKDFFlag = cli.BoolFlag{
		Name:   "lightkdf",
		Usage:  "Reduce key-derivation RAM & CPU usage at some expense of KDF strength",
		EnvVar: "KLAYTN_LIGHTKDF",
	}
	OverwriteGenesisFlag = cli.BoolFlag{
		Name:   "overwrite-genesis",
		Usage:  "Overwrites genesis block with the given new genesis block for testing purpose",
		EnvVar: "KLAYTN_OVERWRITE_GENESIS",
	}
	StartBlockNumberFlag = cli.Uint64Flag{
		Name:   "start-block-num",
		Usage:  "Starts the node from the given block number. Starting from 0 is not supported.",
		EnvVar: "KLAYTN_START_BLOCK_NUM",
	}
	// Transaction pool settings
	TxPoolNoLocalsFlag = cli.BoolFlag{
		Name:   "txpool.nolocals",
		Usage:  "Disables price exemptions for locally submitted transactions",
		EnvVar: "KLAYTN_TXPOOL_NOLOCALS",
	}
	TxPoolAllowLocalAnchorTxFlag = cli.BoolFlag{
		Name:   "txpool.allow-local-anchortx",
		Usage:  "Allow locally submitted anchoring transactions",
		EnvVar: "KLAYTN_TXPOOL_ALLOW_LOCAL_ANCHORTX",
	}
	TxPoolDenyRemoteTxFlag = cli.BoolFlag{
		Name:   "txpool.deny.remotetx",
		Usage:  "Deny remote transaction receiving from other peers. Use only for emergency cases",
		EnvVar: "KLAYTN_TXPOOL_DENY_REMOTETX",
	}
	TxPoolJournalFlag = cli.StringFlag{
		Name:   "txpool.journal",
		Usage:  "Disk journal for local transaction to survive node restarts",
		Value:  blockchain.DefaultTxPoolConfig.Journal,
		EnvVar: "KLAYTN_TXPOOL_JOURNAL",
	}
	TxPoolJournalIntervalFlag = cli.DurationFlag{
		Name:   "txpool.journal-interval",
		Usage:  "Time interval to regenerate the local transaction journal",
		Value:  blockchain.DefaultTxPoolConfig.JournalInterval,
		EnvVar: "KLAYTN_TXPOOL_JOURNAL_INTERVAL",
	}
	TxPoolPriceLimitFlag = cli.Uint64Flag{
		Name:   "txpool.pricelimit",
		Usage:  "Minimum gas price limit to enforce for acceptance into the pool",
		Value:  cn.GetDefaultConfig().TxPool.PriceLimit,
		EnvVar: "KLAYTN_TXPOOL_PRICELIMIT",
	}
	TxPoolPriceBumpFlag = cli.Uint64Flag{
		Name:   "txpool.pricebump",
		Usage:  "Price bump percentage to replace an already existing transaction",
		Value:  cn.GetDefaultConfig().TxPool.PriceBump,
		EnvVar: "KLAYTN_TXPOOL_PRICEBUMP",
	}
	TxPoolExecSlotsAccountFlag = cli.Uint64Flag{
		Name:   "txpool.exec-slots.account",
		Usage:  "Number of executable transaction slots guaranteed per account",
		Value:  cn.GetDefaultConfig().TxPool.ExecSlotsAccount,
		EnvVar: "KLAYTN_TXPOOL_EXEC_SLOTS_ACCOUNT",
	}
	TxPoolExecSlotsAllFlag = cli.Uint64Flag{
		Name:   "txpool.exec-slots.all",
		Usage:  "Maximum number of executable transaction slots for all accounts",
		Value:  cn.GetDefaultConfig().TxPool.ExecSlotsAll,
		EnvVar: "KLAYTN_TXPOOL_EXEC_SLOTS_ALL",
	}
	TxPoolNonExecSlotsAccountFlag = cli.Uint64Flag{
		Name:   "txpool.nonexec-slots.account",
		Usage:  "Maximum number of non-executable transaction slots permitted per account",
		Value:  cn.GetDefaultConfig().TxPool.NonExecSlotsAccount,
		EnvVar: "KLAYTN_TXPOOL_NONEXEC_SLOTS_ACCOUNT",
	}
	TxPoolNonExecSlotsAllFlag = cli.Uint64Flag{
		Name:   "txpool.nonexec-slots.all",
		Usage:  "Maximum number of non-executable transaction slots for all accounts",
		Value:  cn.GetDefaultConfig().TxPool.NonExecSlotsAll,
		EnvVar: "KLAYTN_TXPOOL_NONEXEC_SLOTS_ALL",
	}
	TxPoolKeepLocalsFlag = cli.BoolFlag{
		Name:   "txpool.keeplocals",
		Usage:  "Disables removing timed-out local transactions",
		EnvVar: "KLAYTN_TXPOOL_KEEPLOCALS",
	}
	TxPoolLifetimeFlag = cli.DurationFlag{
		Name:   "txpool.lifetime",
		Usage:  "Maximum amount of time non-executable transaction are queued",
		Value:  cn.GetDefaultConfig().TxPool.Lifetime,
		EnvVar: "KLAYTN_TXPOOL_LIFETIME",
	}
	// PN specific txpool settings
	TxPoolSpamThrottlerDisableFlag = cli.BoolFlag{
		Name:   "txpool.spamthrottler.disable",
		Usage:  "Disable txpool spam throttler prototype",
		EnvVar: "KLAYTN_TXPOOL_SPAMTHROTTLER_DISABLE",
	}

	// KES
	KESNodeTypeServiceFlag = cli.BoolFlag{
		Name:   "kes.nodetype.service",
		Usage:  "Run as a KES Service Node (Disable fetcher, downloader, and worker)",
		EnvVar: "KLAYTN_KES_NODETYPE_SERVICE",
	}
	SingleDBFlag = cli.BoolFlag{
		Name:   "db.single",
		Usage:  "Create a single persistent storage. MiscDB, headerDB and etc are stored in one DB.",
		EnvVar: "KLAYTN_DB_SINGLE",
	}
	NumStateTrieShardsFlag = cli.UintFlag{
		Name:   "db.num-statetrie-shards",
		Usage:  "Number of internal shards of state trie DB shards. Should be power of 2",
		Value:  4,
		EnvVar: "KLAYTN_DB_NUM_STATETRIE_SHARDS",
	}
	LevelDBCacheSizeFlag = cli.IntFlag{
		Name:   "db.leveldb.cache-size",
		Usage:  "Size of in-memory cache in LevelDB (MiB)",
		Value:  768,
		EnvVar: "KLAYTN_DB_LEVELDB_CACHE_SIZE",
	}
	// TODO-Klaytn-Database LevelDBCompressionTypeFlag should be removed before main-net release.
	LevelDBCompressionTypeFlag = cli.IntFlag{
		Name:   "db.leveldb.compression",
		Usage:  "Determines the compression method for LevelDB. 0=AllNoCompression, 1=ReceiptOnlySnappyCompression, 2=StateTrieOnlyNoCompression, 3=AllSnappyCompression",
		Value:  0,
		EnvVar: "KLAYTN_DB_LEVELDB_COMPRESSION",
	}
	LevelDBNoBufferPoolFlag = cli.BoolFlag{
		Name:   "db.leveldb.no-buffer-pool",
		Usage:  "Disables using buffer pool for LevelDB's block allocation",
		EnvVar: "KLAYTN_DB_LEVELDB_NO_BUFFER_POOL",
	}
	DynamoDBTableNameFlag = cli.StringFlag{
		Name:   "db.dynamo.tablename",
		Usage:  "Specifies DynamoDB table name. This is mandatory to use dynamoDB. (Set dbtype to use DynamoDBS3)",
		EnvVar: "KLAYTN_DB_DYNAMO_TABLENAME",
	}
	DynamoDBRegionFlag = cli.StringFlag{
		Name:   "db.dynamo.region",
		Usage:  "AWS region where the DynamoDB will be created.",
		Value:  database.GetDefaultDynamoDBConfig().Region,
		EnvVar: "KLAYTN_DB_DYNAMO_REGION",
	}
	DynamoDBIsProvisionedFlag = cli.BoolFlag{
		Name:   "db.dynamo.is-provisioned",
		Usage:  "Set DynamoDB billing mode to provision. The default billing mode is on-demand.",
		EnvVar: "KLAYTN_DB_DYNAMO_IS_PROVISIONED",
	}
	DynamoDBReadCapacityFlag = cli.Int64Flag{
		Name:   "db.dynamo.read-capacity",
		Usage:  "Read capacity unit of dynamoDB. If is-provisioned is not set, this flag will not be applied.",
		Value:  database.GetDefaultDynamoDBConfig().ReadCapacityUnits,
		EnvVar: "KLAYTN_DB_DYNAMO_READ_CAPACITY",
	}
	DynamoDBWriteCapacityFlag = cli.Int64Flag{
		Name:   "db.dynamo.write-capacity",
		Usage:  "Write capacity unit of dynamoDB. If is-provisioned is not set, this flag will not be applied",
		Value:  database.GetDefaultDynamoDBConfig().WriteCapacityUnits,
		EnvVar: "KLAYTN_DB_DYNAMO_WRITE_CAPACITY",
	}
	DynamoDBReadOnlyFlag = cli.BoolFlag{
		Name:   "db.dynamo.read-only",
		Usage:  "Disables write to DynamoDB. Only read is possible.",
		EnvVar: "KLAYTN_DB_DYNAMO_READ_ONLY",
	}
	NoParallelDBWriteFlag = cli.BoolFlag{
		Name:   "db.no-parallel-write",
		Usage:  "Disables parallel writes of block data to persistent database",
		EnvVar: "KLAYTN_DB_NO_PARALLEL_WRITE",
	}
	DBNoPerformanceMetricsFlag = cli.BoolFlag{
		Name:   "db.no-perf-metrics",
		Usage:  "Disables performance metrics of database's read and write operations",
		EnvVar: "KLAYTN_DB_NO_PERF_METRICS",
	}
	SnapshotFlag = cli.BoolFlag{
		Name:   "snapshot",
		Usage:  "Enables snapshot-database mode",
		EnvVar: "KLAYTN_SNAPSHOT",
	}
	SnapshotCacheSizeFlag = cli.IntFlag{
		Name:   "snapshot.cache-size",
		Usage:  "Size of in-memory cache of the state snapshot cache (in MiB)",
		Value:  512,
		EnvVar: "KLAYTN_SNAPSHOT_CACHE_SIZE",
	}
	SnapshotAsyncGen = cli.BoolTFlag{
		Name:   "snapshot.async-gen",
		Usage:  "Enables snapshot data generation in background",
		EnvVar: "KLAYTN_SNAPSHOT_BACKGROUND_GENERATION",
	}
	TrieMemoryCacheSizeFlag = cli.IntFlag{
		Name:   "state.cache-size",
		Usage:  "Size of in-memory cache of the global state (in MiB) to flush matured singleton trie nodes to disk",
		Value:  512,
		EnvVar: "KLAYTN_STATE_CACHE_SIZE",
	}
	TrieBlockIntervalFlag = cli.UintFlag{
		Name:   "state.block-interval",
		Usage:  "An interval in terms of block number to commit the global state to disk",
		Value:  blockchain.DefaultBlockInterval,
		EnvVar: "KLAYTN_STATE_BLOCK_INTERVAL",
	}
	TriesInMemoryFlag = cli.Uint64Flag{
		Name:   "state.tries-in-memory",
		Usage:  "The number of recent state tries residing in the memory",
		Value:  blockchain.DefaultTriesInMemory,
		EnvVar: "KLAYTN_STATE_TRIES_IN_MEMORY",
	}
	CacheTypeFlag = cli.IntFlag{
		Name:   "cache.type",
		Usage:  "Cache Type: 0=LRUCache, 1=LRUShardCache, 2=FIFOCache",
		Value:  int(common.DefaultCacheType),
		EnvVar: "KLAYTN_CACHE_TYPE",
	}
	CacheScaleFlag = cli.IntFlag{
		Name:   "cache.scale",
		Usage:  "Scale of cache (cache size = preset size * scale of cache(%))",
		EnvVar: "KLAYTN_CACHE_SCALE",
	}
	CacheUsageLevelFlag = cli.StringFlag{
		Name:   "cache.level",
		Usage:  "Set the cache usage level ('saving', 'normal', 'extreme')",
		EnvVar: "KLAYTN_CACHE_LEVEL",
	}
	MemorySizeFlag = cli.IntFlag{
		Name:   "cache.memory",
		Usage:  "Set the physical RAM size (GB, Default: 16GB)",
		EnvVar: "KLAYTN_CACHE_MEMORY",
	}
	TrieNodeCacheTypeFlag = cli.StringFlag{
		Name: "statedb.cache.type",
		Usage: "Set trie node cache type ('LocalCache', 'RemoteCache', " +
			"'HybridCache') (default = 'LocalCache')",
		Value:  string(statedb.CacheTypeLocal),
		EnvVar: "KLAYTN_STATEDB_CACHE_TYPE",
	}
	NumFetcherPrefetchWorkerFlag = cli.IntFlag{
		Name:   "statedb.cache.num-fetcher-prefetch-worker",
		Usage:  "Number of workers used to prefetch block when fetcher fetches block",
		Value:  32,
		EnvVar: "KLAYTN_STATEDB_CACHE_NUM_FETCHER_PREFETCH_WORKER",
	}
	UseSnapshotForPrefetchFlag = cli.BoolFlag{
		Name:   "statedb.cache.use-snapshot-for-prefetch",
		Usage:  "Use state snapshot functionality while prefetching",
		EnvVar: "KLAYTN_STATEDB_CACHE_USE_SNAPSHOT_FOR_PREFETCH",
	}
	TrieNodeCacheRedisEndpointsFlag = cli.StringSliceFlag{
		Name:   "statedb.cache.redis.endpoints",
		Usage:  "Set endpoints of redis trie node cache. More than one endpoints can be set",
		EnvVar: "KLAYTN_STATEDB_CACHE_REDIS_ENDPOINTS",
	}
	TrieNodeCacheRedisClusterFlag = cli.BoolFlag{
		Name:   "statedb.cache.redis.cluster",
		Usage:  "Enables cluster-enabled mode of redis trie node cache",
		EnvVar: "KLAYTN_STATEDB_CACHE_REDIS_CLUSTER",
	}
	TrieNodeCacheRedisPublishBlockFlag = cli.BoolFlag{
		Name:   "statedb.cache.redis.publish",
		Usage:  "Publishes every committed block to redis trie node cache",
		EnvVar: "KLAYTN_STATEDB_CACHE_REDIS_PUBLISH",
	}
	TrieNodeCacheRedisSubscribeBlockFlag = cli.BoolFlag{
		Name:   "statedb.cache.redis.subscribe",
		Usage:  "Subscribes blocks from redis trie node cache",
		EnvVar: "KLAYTN_STATEDB_CACHE_REDIS_SUBSCRIBE",
	}
	TrieNodeCacheLimitFlag = cli.IntFlag{
		Name:   "state.trie-cache-limit",
		Usage:  "Memory allowance (MiB) to use for caching trie nodes in memory. -1 is for auto-scaling",
		Value:  -1,
		EnvVar: "KLAYTN_STATE_TRIE_CACHE_LIMIT",
	}
	TrieNodeCacheSavePeriodFlag = cli.DurationFlag{
		Name:   "state.trie-cache-save-period",
		Usage:  "Period of saving in memory trie cache to file if fastcache is used, 0 means disabled",
		Value:  0,
		EnvVar: "KLAYTN_STATE_TRIE_CACHE_SAVE_PERIOD",
	}
	SenderTxHashIndexingFlag = cli.BoolFlag{
		Name:   "sendertxhashindexing",
		Usage:  "Enables storing mapping information of senderTxHash to txHash",
		EnvVar: "KLAYTN_SENDERTXHASHINDEXING",
	}
	ChildChainIndexingFlag = cli.BoolFlag{
		Name:   "childchainindexing",
		Usage:  "Enables storing transaction hash of child chain transaction for fast access to child chain data",
		EnvVar: "KLAYTN_CHILDCHAININDEXING",
	}
	TargetGasLimitFlag = cli.Uint64Flag{
		Name:   "targetgaslimit",
		Usage:  "Target gas limit sets the artificial target gas floor for the blocks to mine",
		Value:  params.GenesisGasLimit,
		EnvVar: "KLAYTN_TARGETGASLIMIT",
	}
	ServiceChainSignerFlag = cli.StringFlag{
		Name:   "scsigner",
		Usage:  "Public address for signing blocks in the service chain (default = first account created)",
		Value:  "0",
		EnvVar: "KLAYTN_SCSIGNER",
	}
	RewardbaseFlag = cli.StringFlag{
		Name:   "rewardbase",
		Usage:  "Public address for block consensus rewards (default = first account created)",
		Value:  "0",
		EnvVar: "KLAYTN_REWARDBASE",
	}
	ExtraDataFlag = cli.StringFlag{
		Name:   "extradata",
		Usage:  "Block extra data set by the work (default = client version)",
		EnvVar: "KLAYTN_EXTRADATA",
	}

	TxResendIntervalFlag = cli.Uint64Flag{
		Name:   "txresend.interval",
		Usage:  "Set the transaction resend interval in seconds",
		Value:  uint64(cn.DefaultTxResendInterval),
		EnvVar: "KLAYTN_TXRESEND_INTERVAL",
	}
	TxResendCountFlag = cli.IntFlag{
		Name:   "txresend.max-count",
		Usage:  "Set the max count of resending transactions",
		Value:  cn.DefaultMaxResendTxCount,
		EnvVar: "KLAYTN_TXRESEND_MAX_COUNT",
	}
	// TODO-Klaytn-RemoveLater Remove this flag when we are confident with the new transaction resend logic
	TxResendUseLegacyFlag = cli.BoolFlag{
		Name:   "txresend.use-legacy",
		Usage:  "Enable the legacy transaction resend logic (For testing only)",
		EnvVar: "KLAYTN_TXRESEND_USE_LEGACY",
	}
	// Account settings
	UnlockedAccountFlag = cli.StringFlag{
		Name:   "unlock",
		Usage:  "Comma separated list of accounts to unlock",
		Value:  "",
		EnvVar: "KLAYTN_UNLOCK",
	}
	PasswordFileFlag = cli.StringFlag{
		Name:   "password",
		Usage:  "Password file to use for non-interactive password input",
		Value:  "",
		EnvVar: "KLAYTN_PASSWORD",
	}

	VMEnableDebugFlag = cli.BoolFlag{
		Name:   "vmdebug",
		Usage:  "Record information useful for VM and contract debugging",
		EnvVar: "KLAYTN_VMDEBUG",
	}
	VMLogTargetFlag = cli.IntFlag{
		Name:   "vmlog",
		Usage:  "Set the output target of vmlog precompiled contract (0: no output, 1: file, 2: stdout, 3: both)",
		Value:  0,
		EnvVar: "KLAYTN_VMLOG",
	}
	VMTraceInternalTxFlag = cli.BoolFlag{
		Name:   "vm.internaltx",
		Usage:  "Collect internal transaction data while processing a block",
		EnvVar: "KLAYTN_VM_INTERNALTX",
	}

	// Logging and debug settings
	MetricsEnabledFlag = cli.BoolFlag{
		Name:   metricutils.MetricsEnabledFlag,
		Usage:  "Enable metrics collection and reporting",
		EnvVar: "KLAYTN_METRICUTILS_METRICSENABLEDFLAG",
	}
	PrometheusExporterFlag = cli.BoolFlag{
		Name:   metricutils.PrometheusExporterFlag,
		Usage:  "Enable prometheus exporter",
		EnvVar: "KLAYTN_METRICUTILS_PROMETHEUSEXPORTERFLAG",
	}
	PrometheusExporterPortFlag = cli.IntFlag{
		Name:   metricutils.PrometheusExporterPortFlag,
		Usage:  "Prometheus exporter listening port",
		Value:  61001,
		EnvVar: "KLAYTN_METRICUTILS_PROMETHEUSEXPORTERPORTFLAG",
	}
	// RPC settings
	RPCEnabledFlag = cli.BoolFlag{
		Name:   "rpc",
		Usage:  "Enable the HTTP-RPC server",
		EnvVar: "KLAYTN_RPC",
	}
	RPCListenAddrFlag = cli.StringFlag{
		Name:   "rpcaddr",
		Usage:  "HTTP-RPC server listening interface",
		Value:  node.DefaultHTTPHost,
		EnvVar: "KLAYTN_RPCADDR",
	}
	RPCPortFlag = cli.IntFlag{
		Name:   "rpcport",
		Usage:  "HTTP-RPC server listening port",
		Value:  node.DefaultHTTPPort,
		EnvVar: "KLAYTN_RPCPORT",
	}
	RPCCORSDomainFlag = cli.StringFlag{
		Name:   "rpccorsdomain",
		Usage:  "Comma separated list of domains from which to accept cross origin requests (browser enforced)",
		Value:  "",
		EnvVar: "KLAYTN_RPCCORSDOMAIN",
	}
	RPCVirtualHostsFlag = cli.StringFlag{
		Name:   "rpcvhosts",
		Usage:  "Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard.",
		Value:  strings.Join(node.DefaultConfig.HTTPVirtualHosts, ","),
		EnvVar: "KLAYTN_RPCVHOSTS",
	}
	RPCApiFlag = cli.StringFlag{
		Name:   "rpcapi",
		Usage:  "API's offered over the HTTP-RPC interface",
		Value:  "",
		EnvVar: "KLAYTN_RPCAPI",
	}
	RPCGlobalGasCap = cli.Uint64Flag{
		Name:   "rpc.gascap",
		Usage:  "Sets a cap on gas that can be used in klay_call/estimateGas",
		EnvVar: "KLAYTN_RPC_GASCAP",
	}
	RPCGlobalEVMTimeoutFlag = cli.DurationFlag{
		Name:   "rpc.evmtimeout",
		Usage:  "Sets a timeout used for eth_call (0=infinite)",
		EnvVar: "KLAYTN_RPC_EVMTIMEOUT",
	}
	RPCGlobalEthTxFeeCapFlag = cli.Float64Flag{
		Name:   "rpc.ethtxfeecap",
		Usage:  "Sets a cap on transaction fee (in klay) that can be sent via the eth namespace RPC APIs (0 = no cap)",
		EnvVar: "KLAYTN_RPC_ETHTXFEECAP",
	}
	RPCConcurrencyLimit = cli.IntFlag{
		Name:   "rpc.concurrencylimit",
		Usage:  "Sets a limit of concurrent connection number of HTTP-RPC server",
		Value:  rpc.ConcurrencyLimit,
		EnvVar: "KLAYTN_RPC_CONCURRENCYLIMIT",
	}
	RPCNonEthCompatibleFlag = cli.BoolFlag{
		Name:   "rpc.eth.noncompatible",
		Usage:  "Disables the eth namespace API return formatting for compatibility",
		EnvVar: "KLAYTN_RPC_ETH_NONCOMPATIBLE",
	}
	WSEnabledFlag = cli.BoolFlag{
		Name:   "ws",
		Usage:  "Enable the WS-RPC server",
		EnvVar: "KLAYTN_WS",
	}
	WSListenAddrFlag = cli.StringFlag{
		Name:   "wsaddr",
		Usage:  "WS-RPC server listening interface",
		Value:  node.DefaultWSHost,
		EnvVar: "KLAYTN_WSADDR",
	}
	WSPortFlag = cli.IntFlag{
		Name:   "wsport",
		Usage:  "WS-RPC server listening port",
		Value:  node.DefaultWSPort,
		EnvVar: "KLAYTN_WSPORT",
	}
	WSApiFlag = cli.StringFlag{
		Name:   "wsapi",
		Usage:  "API's offered over the WS-RPC interface",
		Value:  "",
		EnvVar: "KLAYTN_WSAPI",
	}
	WSAllowedOriginsFlag = cli.StringFlag{
		Name:   "wsorigins",
		Usage:  "Origins from which to accept websockets requests",
		Value:  "",
		EnvVar: "KLAYTN_WSORIGINS",
	}
	WSMaxSubscriptionPerConn = cli.IntFlag{
		Name:   "wsmaxsubscriptionperconn",
		Usage:  "Allowed maximum subscription number per a websocket connection",
		Value:  int(rpc.MaxSubscriptionPerWSConn),
		EnvVar: "KLAYTN_WSMAXSUBSCRIPTIONPERCONN",
	}
	WSReadDeadLine = cli.Int64Flag{
		Name:   "wsreaddeadline",
		Usage:  "Set the read deadline on the underlying network connection in seconds. 0 means read will not timeout",
		Value:  rpc.WebsocketReadDeadline,
		EnvVar: "KLAYTN_WSREADDEADLINE",
	}
	WSWriteDeadLine = cli.Int64Flag{
		Name:   "wswritedeadline",
		Usage:  "Set the Write deadline on the underlying network connection in seconds. 0 means write will not timeout",
		Value:  rpc.WebsocketWriteDeadline,
		EnvVar: "KLAYTN_WSWRITEDEADLINE",
	}
	WSMaxConnections = cli.IntFlag{
		Name:   "wsmaxconnections",
		Usage:  "Allowed maximum websocket connection number",
		Value:  3000,
		EnvVar: "KLAYTN_WSMAXCONNECTIONS",
	}
	GRPCEnabledFlag = cli.BoolFlag{
		Name:   "grpc",
		Usage:  "Enable the gRPC server",
		EnvVar: "KLAYTN_GRPC",
	}
	GRPCListenAddrFlag = cli.StringFlag{
		Name:   "grpcaddr",
		Usage:  "gRPC server listening interface",
		Value:  node.DefaultGRPCHost,
		EnvVar: "KLAYTN_GRPCADDR",
	}
	GRPCPortFlag = cli.IntFlag{
		Name:   "grpcport",
		Usage:  "gRPC server listening port",
		Value:  node.DefaultGRPCPort,
		EnvVar: "KLAYTN_GRPCPORT",
	}
	IPCDisabledFlag = cli.BoolFlag{
		Name:   "ipcdisable",
		Usage:  "Disable the IPC-RPC server",
		EnvVar: "KLAYTN_IPCDISABLE",
	}
	IPCPathFlag = DirectoryFlag{
		Name:   "ipcpath",
		Usage:  "Filename for IPC socket/pipe within the datadir (explicit paths escape it)",
		EnvVar: "KLAYTN_IPCPATH",
	}
	ExecFlag = cli.StringFlag{
		Name:   "exec",
		Usage:  "Execute JavaScript statement",
		EnvVar: "KLAYTN_EXEC",
	}
	PreloadJSFlag = cli.StringFlag{
		Name:   "preload",
		Usage:  "Comma separated list of JavaScript files to preload into the console",
		EnvVar: "KLAYTN_PRELOAD",
	}
	APIFilterGetLogsDeadlineFlag = cli.DurationFlag{
		Name:   "api.filter.getLogs.deadline",
		Usage:  "Execution deadline for log collecting filter APIs",
		Value:  filters.GetLogsDeadline,
		EnvVar: "KLAYTN_API_FILTER_GETLOGS_DEADLINE",
	}
	APIFilterGetLogsMaxItemsFlag = cli.IntFlag{
		Name:   "api.filter.getLogs.maxitems",
		Usage:  "Maximum allowed number of return items for log collecting filter API",
		Value:  filters.GetLogsMaxItems,
		EnvVar: "KLAYTN_API_FILTER_GETLOGS_MAXITEMS",
	}
	RPCReadTimeout = cli.IntFlag{
		Name:   "rpcreadtimeout",
		Usage:  "HTTP-RPC server read timeout (seconds)",
		Value:  int(rpc.DefaultHTTPTimeouts.ReadTimeout / time.Second),
		EnvVar: "KLAYTN_RPCREADTIMEOUT",
	}
	RPCWriteTimeoutFlag = cli.IntFlag{
		Name:   "rpcwritetimeout",
		Usage:  "HTTP-RPC server write timeout (seconds)",
		Value:  int(rpc.DefaultHTTPTimeouts.WriteTimeout / time.Second),
		EnvVar: "KLAYTN_RPCWRITETIMEOUT",
	}
	RPCIdleTimeoutFlag = cli.IntFlag{
		Name:   "rpcidletimeout",
		Usage:  "HTTP-RPC server idle timeout (seconds)",
		Value:  int(rpc.DefaultHTTPTimeouts.IdleTimeout / time.Second),
		EnvVar: "KLAYTN_RPCIDLETIMEOUT",
	}
	RPCExecutionTimeoutFlag = cli.IntFlag{
		Name:   "rpcexecutiontimeout",
		Usage:  "HTTP-RPC server execution timeout (seconds)",
		Value:  int(rpc.DefaultHTTPTimeouts.ExecutionTimeout / time.Second),
		EnvVar: "KLAYTN_RPCEXECUTIONTIMEOUT",
	}
	UnsafeDebugDisableFlag = cli.BoolFlag{
		Name:   "rpc.unsafe-debug.disable",
		Usage:  "Disable unsafe debug APIs (traceTransaction, writeXXX, ...).",
		EnvVar: "KLAYTN_RPC_UNSAFE_DEBUG_DISABLE",
	}

	// Network Settings
	NodeTypeFlag = cli.StringFlag{
		Name:   "nodetype",
		Usage:  "Klaytn node type (consensus node (cn), proxy node (pn), endpoint node (en))",
		Value:  "en",
		EnvVar: "KLAYTN_NODETYPE",
	}
	MaxConnectionsFlag = cli.IntFlag{
		Name:   "maxconnections",
		Usage:  "Maximum number of physical connections. All single channel peers can be maxconnections peers. All multi channel peers can be maxconnections/2 peers. (network disabled if set to 0)",
		Value:  node.DefaultMaxPhysicalConnections,
		EnvVar: "KLAYTN_MAXCONNECTIONS",
	}
	MaxPendingPeersFlag = cli.IntFlag{
		Name:   "maxpendpeers",
		Usage:  "Maximum number of pending connection attempts (defaults used if set to 0)",
		Value:  0,
		EnvVar: "KLAYTN_MAXPENDPEERS",
	}
	ListenPortFlag = cli.IntFlag{
		Name:   "port",
		Usage:  "Network listening port",
		Value:  node.DefaultP2PPort,
		EnvVar: "KLAYTN_PORT",
	}
	SubListenPortFlag = cli.IntFlag{
		Name:   "subport",
		Usage:  "Network sub listening port",
		Value:  node.DefaultP2PSubPort,
		EnvVar: "KLAYTN_SUBPORT",
	}
	MultiChannelUseFlag = cli.BoolFlag{
		Name:   "multichannel",
		Usage:  "Create a dedicated channel for block propagation",
		EnvVar: "KLAYTN_MULTICHANNEL",
	}
	BootnodesFlag = cli.StringFlag{
		Name:   "bootnodes",
		Usage:  "Comma separated kni URLs for P2P discovery bootstrap",
		Value:  "",
		EnvVar: "KLAYTN_BOOTNODES",
	}
	NodeKeyFileFlag = cli.StringFlag{
		Name:   "nodekey",
		Usage:  "P2P node key file",
		EnvVar: "KLAYTN_NODEKEY",
	}
	NodeKeyHexFlag = cli.StringFlag{
		Name:   "nodekeyhex",
		Usage:  "P2P node key as hex (for testing)",
		EnvVar: "KLAYTN_NODEKEYHEX",
	}
	NATFlag = cli.StringFlag{
		Name:   "nat",
		Usage:  "NAT port mapping mechanism (any|none|upnp|pmp|extip:<IP>)",
		Value:  "any",
		EnvVar: "KLAYTN_NAT",
	}
	NoDiscoverFlag = cli.BoolFlag{
		Name:   "nodiscover",
		Usage:  "Disables the peer discovery mechanism (manual peer addition)",
		EnvVar: "KLAYTN_NODISCOVER",
	}
	NetrestrictFlag = cli.StringFlag{
		Name:   "netrestrict",
		Usage:  "Restricts network communication to the given IP network (CIDR masks)",
		EnvVar: "KLAYTN_NETRESTRICT",
	}
	AnchoringPeriodFlag = cli.Uint64Flag{
		Name:   "chaintxperiod",
		Usage:  "The period to make and send a chain transaction to the parent chain",
		Value:  1,
		EnvVar: "KLAYTN_CHAINTXPERIOD",
	}
	SentChainTxsLimit = cli.Uint64Flag{
		Name:   "chaintxlimit",
		Usage:  "Number of service chain transactions stored for resending",
		Value:  100,
		EnvVar: "KLAYTN_CHAINTXLIMIT",
	}
	RWTimerIntervalFlag = cli.Uint64Flag{
		Name:   "rwtimerinterval",
		Usage:  "Interval of using rw timer to check if it works well",
		Value:  1000,
		EnvVar: "KLAYTN_RWTIMERINTERVAL",
	}
	RWTimerWaitTimeFlag = cli.DurationFlag{
		Name:   "rwtimerwaittime",
		Usage:  "Wait time the rw timer waits for message writing",
		Value:  15 * time.Second,
		EnvVar: "KLAYTN_RWTIMERWAITTIME",
	}
	MaxRequestContentLengthFlag = cli.IntFlag{
		Name:   "maxRequestContentLength",
		Usage:  "Max request content length in byte for http, websocket and gRPC",
		Value:  common.MaxRequestContentLength,
		EnvVar: "KLAYTN_MAXREQUESTCONTENTLENGTH",
	}

	// ATM the url is left to the user and deployment to
	JSpathFlag = cli.StringFlag{
		Name:   "jspath",
		Usage:  "JavaScript root path for `loadScript`",
		Value:  ".",
		EnvVar: "KLAYTN_JSPATH",
	}
	CypressFlag = cli.BoolFlag{
		Name:   "cypress",
		Usage:  "Pre-configured Klaytn Cypress network",
		EnvVar: "KLAYTN_CYPRESS",
	}
	// Baobab bootnodes setting
	BaobabFlag = cli.BoolFlag{
		Name:   "baobab",
		Usage:  "Pre-configured Klaytn baobab network",
		EnvVar: "KLAYTN_BAOBAB",
	}
	// Bootnode's settings
	AuthorizedNodesFlag = cli.StringFlag{
		Name:   "authorized-nodes",
		Usage:  "Comma separated kni URLs for authorized nodes list",
		Value:  "",
		EnvVar: "KLAYTN_AUTHORIZED_NODES",
	}
	// TODO-Klaytn-Bootnode the boodnode flags should be updated when it is implemented
	BNAddrFlag = cli.StringFlag{
		Name:   "bnaddr",
		Usage:  `udp address to use node discovery`,
		Value:  ":32323",
		EnvVar: "KLAYTN_BNADDR",
	}
	GenKeyFlag = cli.StringFlag{
		Name:   "genkey",
		Usage:  "generate a node private key and write to given filename",
		EnvVar: "KLAYTN_GENKEY",
	}
	WriteAddressFlag = cli.BoolFlag{
		Name:   "writeaddress",
		Usage:  `write out the node's public key which is given by "--nodekeyfile" or "--nodekeyhex"`,
		EnvVar: "KLAYTN_WRITEADDRESS",
	}
	// ServiceChain's settings
	MainBridgeFlag = cli.BoolFlag{
		Name:   "mainbridge",
		Usage:  "Enable main bridge service for service chain",
		EnvVar: "KLAYTN_MAINBRIDGE",
	}
	SubBridgeFlag = cli.BoolFlag{
		Name:   "subbridge",
		Usage:  "Enable sub bridge service for service chain",
		EnvVar: "KLAYTN_SUBBRIDGE",
	}
	MainBridgeListenPortFlag = cli.IntFlag{
		Name:   "mainbridgeport",
		Usage:  "main bridge listen port",
		Value:  50505,
		EnvVar: "KLAYTN_MAINBRIDGEPORT",
	}
	SubBridgeListenPortFlag = cli.IntFlag{
		Name:   "subbridgeport",
		Usage:  "sub bridge listen port",
		Value:  50506,
		EnvVar: "KLAYTN_SUBBRIDGEPORT",
	}
	ParentChainIDFlag = cli.IntFlag{
		Name:   "parentchainid",
		Usage:  "parent chain ID",
		Value:  8217,
		EnvVar: "KLAYTN_PARENTCHAINID",
	}
	VTRecoveryFlag = cli.BoolFlag{
		Name:   "vtrecovery",
		Usage:  "Enable value transfer recovery (default: false)",
		EnvVar: "KLAYTN_VTRECOVERY",
	}
	VTRecoveryIntervalFlag = cli.Uint64Flag{
		Name:   "vtrecoveryinterval",
		Usage:  "Set the value transfer recovery interval (seconds)",
		Value:  5,
		EnvVar: "KLAYTN_VTRECOVERYINTERVAL",
	}
	ServiceChainParentOperatorTxGasLimitFlag = cli.Uint64Flag{
		Name:   "sc.parentoperator.gaslimit",
		Usage:  "Set the default value of gas limit for transactions made by bridge parent operator",
		Value:  10000000,
		EnvVar: "KLAYTN_SC_PARENTOPERATOR_GASLIMIT",
	}
	ServiceChainChildOperatorTxGasLimitFlag = cli.Uint64Flag{
		Name:   "sc.childoperator.gaslimit",
		Usage:  "Set the default value of gas limit for transactions made by bridge child operator",
		Value:  10000000,
		EnvVar: "KLAYTN_SC_CHILDOPERATOR_GASLIMIT",
	}
	ServiceChainNewAccountFlag = cli.BoolFlag{
		Name:   "scnewaccount",
		Usage:  "Enable account creation for the service chain (default: false). If set true, generated account can't be synced with the parent chain.",
		EnvVar: "KLAYTN_SCNEWACCOUNT",
	}
	ServiceChainConsensusFlag = cli.StringFlag{
		Name:   "scconsensus",
		Usage:  "Set the service chain consensus (\"istanbul\", \"clique\")",
		Value:  "istanbul",
		EnvVar: "KLAYTN_SCCONSENSUS",
	}
	ServiceChainAnchoringFlag = cli.BoolFlag{
		Name:   "anchoring",
		Usage:  "Enable anchoring for service chain",
		EnvVar: "KLAYTN_ANCHORING",
	}

	// KAS
	KASServiceChainAnchorFlag = cli.BoolFlag{
		Name:   "kas.sc.anchor",
		Usage:  "Enable KAS anchoring for service chain",
		EnvVar: "KLAYTN_KAS_SC_ANCHOR",
	}
	KASServiceChainAnchorPeriodFlag = cli.Uint64Flag{
		Name:   "kas.sc.anchor.period",
		Usage:  "The period to anchor service chain blocks to KAS",
		Value:  1,
		EnvVar: "KLAYTN_KAS_SC_ANCHOR_PERIOD",
	}
	KASServiceChainAnchorUrlFlag = cli.StringFlag{
		Name:   "kas.sc.anchor.url",
		Usage:  "The url for KAS anchor",
		EnvVar: "KLAYTN_KAS_SC_ANCHOR_URL",
	}
	KASServiceChainAnchorOperatorFlag = cli.StringFlag{
		Name:   "kas.sc.anchor.operator",
		Usage:  "The operator address for KAS anchor",
		EnvVar: "KLAYTN_KAS_SC_ANCHOR_OPERATOR",
	}
	KASServiceChainAnchorRequestTimeoutFlag = cli.DurationFlag{
		Name:   "kas.sc.anchor.request.timeout",
		Usage:  "The reuqest timeout for KAS Anchoring API call",
		Value:  500 * time.Millisecond,
		EnvVar: "KLAYTN_KAS_SC_ANCHOR_REQUEST_TIMEOUT",
	}
	KASServiceChainXChainIdFlag = cli.StringFlag{
		Name:   "kas.x-chain-id",
		Usage:  "The x-chain-id for KAS",
		EnvVar: "KLAYTN_KAS_X_CHAIN_ID",
	}
	KASServiceChainAccessKeyFlag = cli.StringFlag{
		Name:   "kas.accesskey",
		Usage:  "The access key id for KAS",
		EnvVar: "KLAYTN_KAS_ACCESSKEY",
	}
	KASServiceChainSecretKeyFlag = cli.StringFlag{
		Name:   "kas.secretkey",
		Usage:  "The secret key for KAS",
		EnvVar: "KLAYTN_KAS_SECRETKEY",
	}

	// ChainDataFetcher
	EnableChainDataFetcherFlag = cli.BoolFlag{
		Name:   "chaindatafetcher",
		Usage:  "Enable the ChainDataFetcher Service",
		EnvVar: "KLAYTN_CHAINDATAFETCHER",
	}
	ChainDataFetcherMode = cli.StringFlag{
		Name:   "chaindatafetcher.mode",
		Usage:  "The mode of chaindatafetcher (\"kas\", \"kafka\")",
		Value:  "kas",
		EnvVar: "KLAYTN_CHAINDATAFETCHER_MODE",
	}
	ChainDataFetcherNoDefault = cli.BoolFlag{
		Name:   "chaindatafetcher.no.default",
		Usage:  "Turn off the starting of the chaindatafetcher",
		EnvVar: "KLAYTN_CHAINDATAFETCHER_NO_DEFAULT",
	}
	ChainDataFetcherNumHandlers = cli.IntFlag{
		Name:   "chaindatafetcher.num.handlers",
		Usage:  "Number of chaindata handlers",
		Value:  chaindatafetcher.DefaultNumHandlers,
		EnvVar: "KLAYTN_CHAINDATAFETCHER_NUM_HANDLERS",
	}
	ChainDataFetcherJobChannelSize = cli.IntFlag{
		Name:   "chaindatafetcher.job.channel.size",
		Usage:  "Job channel size",
		Value:  chaindatafetcher.DefaultJobChannelSize,
		EnvVar: "KLAYTN_CHAINDATAFETCHER_JOB_CHANNEL_SIZE",
	}
	ChainDataFetcherChainEventSizeFlag = cli.IntFlag{
		Name:   "chaindatafetcher.block.channel.size",
		Usage:  "Block received channel size",
		Value:  chaindatafetcher.DefaultJobChannelSize,
		EnvVar: "KLAYTN_CHAINDATAFETCHER_BLOCK_CHANNEL_SIZE",
	}
	ChainDataFetcherMaxProcessingDataSize = cli.IntFlag{
		Name:   "chaindatafetcher.max.processing.data.size",
		Usage:  "Maximum size of processing data before requesting range fetching of blocks (in MB)",
		Value:  chaindatafetcher.DefaultMaxProcessingDataSize,
		EnvVar: "KLAYTN_CHAINDATAFETCHER_MAX_PROCESSING_DATA_SIZE",
	}
	ChainDataFetcherKASDBHostFlag = cli.StringFlag{
		Name:   "chaindatafetcher.kas.db.host",
		Usage:  "KAS specific DB host in chaindatafetcher",
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAS_DB_HOST",
	}
	ChainDataFetcherKASDBPortFlag = cli.StringFlag{
		Name:   "chaindatafetcher.kas.db.port",
		Usage:  "KAS specific DB port in chaindatafetcher",
		Value:  chaindatafetcher.DefaultDBPort,
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAS_DB_PORT",
	}
	ChainDataFetcherKASDBNameFlag = cli.StringFlag{
		Name:   "chaindatafetcher.kas.db.name",
		Usage:  "KAS specific DB name in chaindatafetcher",
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAS_DB_NAME",
	}
	ChainDataFetcherKASDBUserFlag = cli.StringFlag{
		Name:   "chaindatafetcher.kas.db.user",
		Usage:  "KAS specific DB user in chaindatafetcher",
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAS_DB_USER",
	}
	ChainDataFetcherKASDBPasswordFlag = cli.StringFlag{
		Name:   "chaindatafetcher.kas.db.password",
		Usage:  "KAS specific DB password in chaindatafetcher",
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAS_DB_PASSWORD",
	}
	ChainDataFetcherKASCacheUse = cli.BoolFlag{
		Name:   "chaindatafetcher.kas.cache.use",
		Usage:  "Enable KAS cache invalidation",
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAS_CACHE_USE",
	}
	ChainDataFetcherKASCacheURLFlag = cli.StringFlag{
		Name:   "chaindatafetcher.kas.cache.url",
		Usage:  "KAS specific cache invalidate API endpoint in chaindatafetcher",
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAS_CACHE_URL",
	}
	ChainDataFetcherKASXChainIdFlag = cli.StringFlag{
		Name:   "chaindatafetcher.kas.xchainid",
		Usage:  "KAS specific header x-chain-id in chaindatafetcher",
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAS_XCHAINID",
	}
	ChainDataFetcherKASBasicAuthParamFlag = cli.StringFlag{
		Name:   "chaindatafetcher.kas.basic.auth.param",
		Usage:  "KAS specific header basic authorization parameter in chaindatafetcher",
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAS_BASIC_AUTH_PARAM",
	}
	ChainDataFetcherKafkaBrokersFlag = cli.StringSliceFlag{
		Name:   "chaindatafetcher.kafka.brokers",
		Usage:  "Kafka broker URL list",
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAFKA_BROKERS",
	}
	ChainDataFetcherKafkaTopicEnvironmentFlag = cli.StringFlag{
		Name:   "chaindatafetcher.kafka.topic.environment",
		Usage:  "Kafka topic environment prefix",
		Value:  kafka.DefaultTopicEnvironmentName,
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAFKA_TOPIC_ENVIRONMENT",
	}
	ChainDataFetcherKafkaTopicResourceFlag = cli.StringFlag{
		Name:   "chaindatafetcher.kafka.topic.resource",
		Usage:  "Kafka topic resource name",
		Value:  kafka.DefaultTopicResourceName,
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAFKA_TOPIC_RESOURCE",
	}
	ChainDataFetcherKafkaReplicasFlag = cli.Int64Flag{
		Name:   "chaindatafetcher.kafka.replicas",
		Usage:  "Kafka partition replication factor",
		Value:  kafka.DefaultReplicas,
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAFKA_REPLICAS",
	}
	ChainDataFetcherKafkaPartitionsFlag = cli.IntFlag{
		Name:   "chaindatafetcher.kafka.partitions",
		Usage:  "The number of partitions in a topic",
		Value:  kafka.DefaultPartitions,
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAFKA_PARTITIONS",
	}
	ChainDataFetcherKafkaMaxMessageBytesFlag = cli.Int64Flag{
		Name:   "chaindatafetcher.kafka.max.message.bytes",
		Usage:  "The max size of a message produced by Kafka producer ",
		Value:  kafka.DefaultMaxMessageBytes,
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAFKA_MAX_MESSAGE_BYTES",
	}
	ChainDataFetcherKafkaSegmentSizeBytesFlag = cli.IntFlag{
		Name:   "chaindatafetcher.kafka.segment.size",
		Usage:  "The kafka data segment size (in byte)",
		Value:  kafka.DefaultSegmentSizeBytes,
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAFKA_SEGMENT_SIZE",
	}
	ChainDataFetcherKafkaRequiredAcksFlag = cli.IntFlag{
		Name:   "chaindatafetcher.kafka.required.acks",
		Usage:  "The level of acknowledgement reliability needed from Kafka broker (0: NoResponse, 1: WaitForLocal, -1: WaitForAll)",
		Value:  kafka.DefaultRequiredAcks,
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAFKA_REQUIRED_ACKS",
	}
	ChainDataFetcherKafkaMessageVersionFlag = cli.StringFlag{
		Name:   "chaindatafetcher.kafka.msg.version",
		Usage:  "The version of Kafka message",
		Value:  kafka.DefaultKafkaMessageVersion,
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAFKA_MSG_VERSION",
	}
	ChainDataFetcherKafkaProducerIdFlag = cli.StringFlag{
		Name:   "chaindatafetcher.kafka.producer.id",
		Usage:  "The identifier of kafka message producer",
		Value:  kafka.GetDefaultProducerId(),
		EnvVar: "KLAYTN_CHAINDATAFETCHER_KAFKA_PRODUCER_ID",
	}
	// DBSyncer
	EnableDBSyncerFlag = cli.BoolFlag{
		Name:   "dbsyncer",
		Usage:  "Enable the DBSyncer",
		EnvVar: "KLAYTN_DBSYNCER",
	}
	DBHostFlag = cli.StringFlag{
		Name:   "dbsyncer.db.host",
		Usage:  "db.host in dbsyncer",
		EnvVar: "KLAYTN_DBSYNCER_DB_HOST",
	}
	DBPortFlag = cli.StringFlag{
		Name:   "dbsyncer.db.port",
		Usage:  "db.port in dbsyncer",
		Value:  "3306",
		EnvVar: "KLAYTN_DBSYNCER_DB_PORT",
	}
	DBNameFlag = cli.StringFlag{
		Name:   "dbsyncer.db.name",
		Usage:  "db.name in dbsyncer",
		EnvVar: "KLAYTN_DBSYNCER_DB_NAME",
	}
	DBUserFlag = cli.StringFlag{
		Name:   "dbsyncer.db.user",
		Usage:  "db.user in dbsyncer",
		EnvVar: "KLAYTN_DBSYNCER_DB_USER",
	}
	DBPasswordFlag = cli.StringFlag{
		Name:   "dbsyncer.db.password",
		Usage:  "db.password in dbsyncer",
		EnvVar: "KLAYTN_DBSYNCER_DB_PASSWORD",
	}
	EnabledLogModeFlag = cli.BoolFlag{
		Name:   "dbsyncer.logmode",
		Usage:  "Enable the dbsyncer logmode",
		EnvVar: "KLAYTN_DBSYNCER_LOGMODE",
	}
	MaxIdleConnsFlag = cli.IntFlag{
		Name:   "dbsyncer.db.max.idle",
		Usage:  "The maximum number of connections in the idle connection pool",
		Value:  50,
		EnvVar: "KLAYTN_DBSYNCER_DB_MAX_IDLE",
	}
	MaxOpenConnsFlag = cli.IntFlag{
		Name:   "dbsyncer.db.max.open",
		Usage:  "The maximum number of open connections to the database",
		Value:  30,
		EnvVar: "KLAYTN_DBSYNCER_DB_MAX_OPEN",
	}
	ConnMaxLifeTimeFlag = cli.DurationFlag{
		Name:   "dbsyncer.db.max.lifetime",
		Usage:  "The maximum amount of time a connection may be reused (default : 1h), ex: 300ms, 2h45m, 60s, ...",
		Value:  1 * time.Hour,
		EnvVar: "KLAYTN_DBSYNCER_DB_MAX_LIFETIME",
	}
	BlockSyncChannelSizeFlag = cli.IntFlag{
		Name:   "dbsyncer.block.channel.size",
		Usage:  "Block received channel size",
		Value:  5,
		EnvVar: "KLAYTN_DBSYNCER_BLOCK_CHANNEL_SIZE",
	}
	DBSyncerModeFlag = cli.StringFlag{
		Name:   "dbsyncer.mode",
		Usage:  "The mode of dbsyncer is way which handle block/tx data to insert db (multi, single, context)",
		Value:  "multi",
		EnvVar: "KLAYTN_DBSYNCER_MODE",
	}
	GenQueryThreadFlag = cli.IntFlag{
		Name:   "dbsyncer.genquery.th",
		Usage:  "The amount of thread of generation query in multi mode",
		Value:  50,
		EnvVar: "KLAYTN_DBSYNCER_GENQUERY_TH",
	}
	InsertThreadFlag = cli.IntFlag{
		Name:   "dbsyncer.insert.th",
		Usage:  "The amount of thread of insert operation in multi mode",
		Value:  30,
		EnvVar: "KLAYTN_DBSYNCER_INSERT_TH",
	}
	BulkInsertSizeFlag = cli.IntFlag{
		Name:   "dbsyncer.bulk.size",
		Usage:  "The amount of row for bulk-insert",
		Value:  200,
		EnvVar: "KLAYTN_DBSYNCER_BULK_SIZE",
	}
	EventModeFlag = cli.StringFlag{
		Name:   "dbsyncer.event.mode",
		Usage:  "The way how to sync all block or last block (block, head)",
		Value:  "head",
		EnvVar: "KLAYTN_DBSYNCER_EVENT_MODE",
	}
	MaxBlockDiffFlag = cli.Uint64Flag{
		Name:   "dbsyncer.max.block.diff",
		Usage:  "The maximum difference between current block and event block. 0 means off",
		Value:  0,
		EnvVar: "KLAYTN_DBSYNCER_MAX_BLOCK_DIFF",
	}
	AutoRestartFlag = cli.BoolFlag{
		Name:   "autorestart.enable",
		Usage:  "Node can restart itself when there is a problem in making consensus",
		EnvVar: "KLAYTN_AUTORESTART_ENABLE",
	}
	RestartTimeOutFlag = cli.DurationFlag{
		Name:   "autorestart.timeout",
		Usage:  "The elapsed time to wait auto restart (minutes)",
		Value:  15 * time.Minute,
		EnvVar: "KLAYTN_AUTORESTART_TIMEOUT",
	}
	DaemonPathFlag = cli.StringFlag{
		Name:   "autorestart.daemon.path",
		Usage:  "Path of node daemon. Used to give signal to kill",
		Value:  "~/klaytn/bin/kcnd",
		EnvVar: "KLAYTN_AUTORESTART_DAEMON_PATH",
	}

	// db migration vars
	DstDbTypeFlag = cli.StringFlag{
		Name:   "dst.dbtype",
		Usage:  `Blockchain storage database type ("LevelDB", "BadgerDB", "DynamoDBS3")`,
		Value:  "LevelDB",
		EnvVar: "KLAYTN_DST_DBTYPE",
	}
	DstDataDirFlag = DirectoryFlag{
		Name:   "dst.datadir",
		Usage:  "Data directory for the databases and keystore. This value is only used in local DB.",
		EnvVar: "KLAYTN_DST_DATADIR",
	}
	DstSingleDBFlag = cli.BoolFlag{
		Name:   "db.dst.single",
		Usage:  "Create a single persistent storage. MiscDB, headerDB and etc are stored in one DB.",
		EnvVar: "KLAYTN_DB_DST_SINGLE",
	}
	DstLevelDBCacheSizeFlag = cli.IntFlag{
		Name:   "db.dst.leveldb.cache-size",
		Usage:  "Size of in-memory cache in LevelDB (MiB)",
		Value:  768,
		EnvVar: "KLAYTN_DB_DST_LEVELDB_CACHE_SIZE",
	}
	DstLevelDBCompressionTypeFlag = cli.IntFlag{
		Name:   "db.dst.leveldb.compression",
		Usage:  "Determines the compression method for LevelDB. 0=AllNoCompression, 1=ReceiptOnlySnappyCompression, 2=StateTrieOnlyNoCompression, 3=AllSnappyCompression",
		Value:  0,
		EnvVar: "KLAYTN_DB_DST_LEVELDB_COMPRESSION",
	}
	DstNumStateTrieShardsFlag = cli.UintFlag{
		Name:   "db.dst.num-statetrie-shards",
		Usage:  "Number of internal shards of state trie DB shards. Should be power of 2",
		Value:  4,
		EnvVar: "KLAYTN_DB_DST_NUM_STATETRIE_SHARDS",
	}
	DstDynamoDBTableNameFlag = cli.StringFlag{
		Name:   "db.dst.dynamo.tablename",
		Usage:  "Specifies DynamoDB table name. This is mandatory to use dynamoDB. (Set dbtype to use DynamoDBS3). If dstDB is singleDB, tableName should be in form of 'PREFIX-TABLENAME'.(e.g. 'klaytn-misc', 'klaytn-statetrie')",
		EnvVar: "KLAYTN_DB_DST_DYNAMO_TABLENAME",
	}
	DstDynamoDBRegionFlag = cli.StringFlag{
		Name:   "db.dst.dynamo.region",
		Usage:  "AWS region where the DynamoDB will be created.",
		Value:  database.GetDefaultDynamoDBConfig().Region,
		EnvVar: "KLAYTN_DB_DST_DYNAMO_REGION",
	}
	DstDynamoDBIsProvisionedFlag = cli.BoolFlag{
		Name:   "db.dst.dynamo.is-provisioned",
		Usage:  "Set DynamoDB billing mode to provision. The default billing mode is on-demand.",
		EnvVar: "KLAYTN_DB_DST_DYNAMO_IS_PROVISIONED",
	}
	DstDynamoDBReadCapacityFlag = cli.Int64Flag{
		Name:   "db.dst.dynamo.read-capacity",
		Usage:  "Read capacity unit of dynamoDB. If is-provisioned is not set, this flag will not be applied.",
		Value:  database.GetDefaultDynamoDBConfig().ReadCapacityUnits,
		EnvVar: "KLAYTN_DB_DST_DYNAMO_READ_CAPACITY",
	}
	DstDynamoDBWriteCapacityFlag = cli.Int64Flag{
		Name:   "db.dst.dynamo.write-capacity",
		Usage:  "Write capacity unit of dynamoDB. If is-provisioned is not set, this flag will not be applied",
		Value:  database.GetDefaultDynamoDBConfig().WriteCapacityUnits,
		EnvVar: "KLAYTN_DB_DST_DYNAMO_WRITE_CAPACITY",
	}

	// Config
	ConfigFileFlag = cli.StringFlag{
		Name:   "config",
		Usage:  "TOML configuration file",
		EnvVar: "KLAYTN_CONFIG",
	}
	BlockGenerationIntervalFlag = cli.Int64Flag{
		Name: "block-generation-interval",
		Usage: "(experimental option) Set the block generation interval in seconds. " +
			"It should be equal or larger than 1. This flag is only applicable to CN.",
		Value:  params.DefaultBlockGenerationInterval,
		EnvVar: "KLAYTN_BLOCK_GENERATION_INTERVAL",
	}
	BlockGenerationTimeLimitFlag = cli.DurationFlag{
		Name: "block-generation-time-limit",
		Usage: "(experimental option) Set the vm execution time limit during block generation. " +
			"Less than half of the block generation interval is recommended for this value. " +
			"This flag is only applicable to CN",
		Value:  params.DefaultBlockGenerationTimeLimit,
		EnvVar: "KLAYTN_BLOCK_GENERATION_TIME_LIMIT",
	}
	OpcodeComputationCostLimitFlag = cli.Uint64Flag{
		Name: "opcode-computation-cost-limit",
		Usage: "(experimental option) Set the computation cost limit for a tx. " +
			"Should set the same value within the network",
		Value:  params.DefaultOpcodeComputationCostLimit,
		EnvVar: "KLAYTN_OPCODE_COMPUTATION_COST_LIMIT",
	}
)
View Source 
var (
	GlobalAppHelpTemplate = `` /* 637-byte string literal not displayed */

	CommandHelpTemplate = `` /* 471-byte string literal not displayed */

	AppHelpTemplate = `` /* 308-byte string literal not displayed */

	KgenHelpTemplate = `` /* 330-byte string literal not displayed */

)

GlobalAppHelpTemplate is the test template for the default, global app help topic.

View Source 
var FlagGroups = []FlagGroup{
	{
		Name: "KLAY",
		Flags: []cli.Flag{
			NtpDisableFlag,
			NtpServerFlag,
			DbTypeFlag,
			DataDirFlag,
			KeyStoreDirFlag,
			IdentityFlag,
			SyncModeFlag,
			GCModeFlag,
			LightKDFFlag,
			SrvTypeFlag,
			ExtraDataFlag,
			ConfigFileFlag,
			OverwriteGenesisFlag,
			StartBlockNumberFlag,
			BlockGenerationIntervalFlag,
			BlockGenerationTimeLimitFlag,
			OpcodeComputationCostLimitFlag,
		},
	},
	{
		Name: "ACCOUNT",
		Flags: []cli.Flag{
			UnlockedAccountFlag,
			PasswordFileFlag,
		},
	},
	{
		Name: "TXPOOL",
		Flags: []cli.Flag{
			TxPoolNoLocalsFlag,
			TxPoolAllowLocalAnchorTxFlag,
			TxPoolDenyRemoteTxFlag,
			TxPoolJournalFlag,
			TxPoolJournalIntervalFlag,
			TxPoolPriceLimitFlag,
			TxPoolPriceBumpFlag,
			TxPoolExecSlotsAccountFlag,
			TxPoolExecSlotsAllFlag,
			TxPoolNonExecSlotsAccountFlag,
			TxPoolNonExecSlotsAllFlag,
			TxPoolLifetimeFlag,
			TxPoolKeepLocalsFlag,
			TxResendIntervalFlag,
			TxResendCountFlag,
			TxResendUseLegacyFlag,
		},
	},
	{
		Name: "DATABASE",
		Flags: []cli.Flag{
			LevelDBCacheSizeFlag,
			SingleDBFlag,
			NumStateTrieShardsFlag,
			LevelDBCompressionTypeFlag,
			LevelDBNoBufferPoolFlag,
			DynamoDBTableNameFlag,
			DynamoDBRegionFlag,
			DynamoDBIsProvisionedFlag,
			DynamoDBReadCapacityFlag,
			DynamoDBWriteCapacityFlag,
			NoParallelDBWriteFlag,
			SenderTxHashIndexingFlag,
			DBNoPerformanceMetricsFlag,
		},
	},
	{
		Name: "DATABASE SYNCER",
		Flags: []cli.Flag{
			EnableDBSyncerFlag,
			DBHostFlag,
			DBPortFlag,
			DBNameFlag,
			DBUserFlag,
			DBPasswordFlag,
			EnabledLogModeFlag,
			MaxIdleConnsFlag,
			MaxOpenConnsFlag,
			ConnMaxLifeTimeFlag,
			BlockSyncChannelSizeFlag,
			DBSyncerModeFlag,
			GenQueryThreadFlag,
			InsertThreadFlag,
			BulkInsertSizeFlag,
			EventModeFlag,
			MaxBlockDiffFlag,
		},
	},
	{
		Name: "CHAINDATAFETCHER",
		Flags: []cli.Flag{
			EnableChainDataFetcherFlag,
			ChainDataFetcherMode,
			ChainDataFetcherNoDefault,
			ChainDataFetcherNumHandlers,
			ChainDataFetcherJobChannelSize,
			ChainDataFetcherChainEventSizeFlag,
			ChainDataFetcherMaxProcessingDataSize,
			ChainDataFetcherKASDBHostFlag,
			ChainDataFetcherKASDBPortFlag,
			ChainDataFetcherKASDBNameFlag,
			ChainDataFetcherKASDBUserFlag,
			ChainDataFetcherKASDBPasswordFlag,
			ChainDataFetcherKASCacheUse,
			ChainDataFetcherKASCacheURLFlag,
			ChainDataFetcherKASXChainIdFlag,
			ChainDataFetcherKASBasicAuthParamFlag,
			ChainDataFetcherKafkaBrokersFlag,
			ChainDataFetcherKafkaTopicEnvironmentFlag,
			ChainDataFetcherKafkaTopicResourceFlag,
			ChainDataFetcherKafkaReplicasFlag,
			ChainDataFetcherKafkaPartitionsFlag,
			ChainDataFetcherKafkaMaxMessageBytesFlag,
			ChainDataFetcherKafkaSegmentSizeBytesFlag,
			ChainDataFetcherKafkaRequiredAcksFlag,
			ChainDataFetcherKafkaMessageVersionFlag,
			ChainDataFetcherKafkaProducerIdFlag,
		},
	},
	{
		Name: "DATABASE MIGRATION",
		Flags: []cli.Flag{
			DstDbTypeFlag,
			DstDataDirFlag,
			DstSingleDBFlag,
			DstLevelDBCompressionTypeFlag,
			DstNumStateTrieShardsFlag,
			DstDynamoDBTableNameFlag,
			DstDynamoDBRegionFlag,
			DstDynamoDBIsProvisionedFlag,
			DstDynamoDBReadCapacityFlag,
			DstDynamoDBWriteCapacityFlag,
		},
	},
	{
		Name: "STATE",
		Flags: []cli.Flag{
			TrieMemoryCacheSizeFlag,
			TrieBlockIntervalFlag,
			TriesInMemoryFlag,
		},
	},
	{
		Name: "CACHE",
		Flags: []cli.Flag{
			CacheTypeFlag,
			CacheScaleFlag,
			CacheUsageLevelFlag,
			MemorySizeFlag,
			TrieNodeCacheTypeFlag,
			NumFetcherPrefetchWorkerFlag,
			UseSnapshotForPrefetchFlag,
			TrieNodeCacheLimitFlag,
			TrieNodeCacheSavePeriodFlag,
			TrieNodeCacheRedisEndpointsFlag,
			TrieNodeCacheRedisClusterFlag,
			TrieNodeCacheRedisPublishBlockFlag,
			TrieNodeCacheRedisSubscribeBlockFlag,
		},
	},
	{
		Name: "CONSENSUS",
		Flags: []cli.Flag{
			ServiceChainSignerFlag,
			RewardbaseFlag,
		},
	},
	{
		Name: "NETWORKING",
		Flags: []cli.Flag{
			BootnodesFlag,
			ListenPortFlag,
			SubListenPortFlag,
			MultiChannelUseFlag,
			MaxConnectionsFlag,
			MaxPendingPeersFlag,
			TargetGasLimitFlag,
			NATFlag,
			NoDiscoverFlag,
			RWTimerWaitTimeFlag,
			RWTimerIntervalFlag,
			NetrestrictFlag,
			NodeKeyFileFlag,
			NodeKeyHexFlag,
			NetworkIdFlag,
			BaobabFlag,
			CypressFlag,
		},
	},
	{
		Name: "METRICS",
		Flags: []cli.Flag{
			MetricsEnabledFlag,
			PrometheusExporterFlag,
			PrometheusExporterPortFlag,
		},
	},
	{
		Name: "VIRTUAL MACHINE",
		Flags: []cli.Flag{
			VMEnableDebugFlag,
			VMLogTargetFlag,
			VMTraceInternalTxFlag,
		},
	},
	{
		Name: "API AND CONSOLE",
		Flags: []cli.Flag{
			RPCEnabledFlag,
			RPCListenAddrFlag,
			RPCPortFlag,
			RPCCORSDomainFlag,
			RPCVirtualHostsFlag,
			RPCApiFlag,
			RPCGlobalGasCap,
			RPCGlobalEVMTimeoutFlag,
			RPCGlobalEthTxFeeCapFlag,
			RPCConcurrencyLimit,
			RPCNonEthCompatibleFlag,
			UnsafeDebugDisableFlag,
			IPCDisabledFlag,
			IPCPathFlag,
			WSEnabledFlag,
			WSListenAddrFlag,
			WSPortFlag,
			WSApiFlag,
			WSAllowedOriginsFlag,
			GRPCEnabledFlag,
			GRPCListenAddrFlag,
			GRPCPortFlag,
			JSpathFlag,
			ExecFlag,
			PreloadJSFlag,
			MaxRequestContentLengthFlag,
			APIFilterGetLogsDeadlineFlag,
			APIFilterGetLogsMaxItemsFlag,
		},
	},
	{
		Name:  "LOGGING AND DEBUGGING",
		Flags: debug.Flags,
	},
	{
		Name: "SERVICECHAIN",
		Flags: []cli.Flag{
			ChildChainIndexingFlag,
			MainBridgeFlag,
			MainBridgeListenPortFlag,
			SubBridgeFlag,
			SubBridgeListenPortFlag,
			AnchoringPeriodFlag,
			SentChainTxsLimit,
			ParentChainIDFlag,
			VTRecoveryFlag,
			VTRecoveryIntervalFlag,
			ServiceChainAnchoringFlag,
			ServiceChainNewAccountFlag,
			ServiceChainParentOperatorTxGasLimitFlag,
			ServiceChainChildOperatorTxGasLimitFlag,
			KASServiceChainAnchorFlag,
			KASServiceChainAnchorPeriodFlag,
			KASServiceChainAnchorUrlFlag,
			KASServiceChainAnchorOperatorFlag,
			KASServiceChainAccessKeyFlag,
			KASServiceChainSecretKeyFlag,
			KASServiceChainXChainIdFlag,
			KASServiceChainAnchorRequestTimeoutFlag,
		},
	},
	{
		Name: "MISC",
		Flags: []cli.Flag{
			GenKeyFlag,
			WriteAddressFlag,
			AutoRestartFlag,
			RestartTimeOutFlag,
			DaemonPathFlag,
			KESNodeTypeServiceFlag,
			SnapshotFlag,
			SnapshotCacheSizeFlag,
			SnapshotAsyncGen,
		},
	},
}

TODO-Klaytn: consider changing the type of FlagGroups to map FlagGroups categorizes flags into groups to print structured help.

View Source 
var TomlSettings = toml.Config{
	NormFieldName: func(rt reflect.Type, key string) string {
		return key
	},
	FieldToKey: func(rt reflect.Type, field string) string {
		return field
	},
	MissingField: func(rt reflect.Type, field string) error {
		link := ""
		if unicode.IsUpper(rune(rt.Name()[0])) && rt.PkgPath() != "main" {
			link = fmt.Sprintf(", see https://godoc.org/%s#%s for available fields", rt.PkgPath(), rt.Name())
		}
		return fmt.Errorf("field '%s' is not defined in %s%s", field, rt.String(), link)
	},
}

These settings ensure that TOML keys use the same names as Go struct fields.

Functions

func CheckExclusive added in v1.6.0 

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

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

func DefaultNodeConfig added in v1.10.0 

func DefaultNodeConfig() node.Config

func ExportAppendChain 

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

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

func ExportChain 

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

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

func FormatPackage 

func FormatPackage(name string) string

func GlobalBig 

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

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

func ImportChain 

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

func InitHelper 

func InitHelper()

func LoadConfig added in v1.10.0 

func LoadConfig(file string, cfg *KlayConfig) error

func MakeAddress 

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

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

func MakeConsolePreloads 

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

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

func MakeDataDir 

func MakeDataDir(ctx *cli.Context) string

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

func MakePasswordList 

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

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

func MigrateFlags 

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

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

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

is equivalent after calling this method with:

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

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

func NewApp 

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

NewApp creates an app with sane defaults.

func NewCLI 

func NewCLI() *cli.App

NewApp creates an app with sane defaults.

func NewHelpPrinter 

func NewHelpPrinter(fg []FlagGroup) func(w io.Writer, tmp string, data interface{})

func RegisterCNService 

func RegisterCNService(stack *node.Node, cfg *cn.Config)

RegisterCNService adds a CN client to the stack.

func RegisterChainDataFetcherService added in v1.5.2 

func RegisterChainDataFetcherService(stack *node.Node, cfg *chaindatafetcher.ChainDataFetcherConfig)

RegisterChainDataFetcherService adds a ChainDataFetcher to the stack

func RegisterDBSyncerService 

func RegisterDBSyncerService(stack *node.Node, cfg *dbsyncer.DBConfig)

RegisterDBSyncerService adds a DBSyncer to the stack

func RegisterService 

func RegisterService(stack *node.Node, cfg *sc.SCConfig)

func SetP2PConfig 

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

func SplitAndJoin 

func SplitAndJoin(s string, symbol string) string

SplitAndJoin converts a camel-case string to a string joined by the provided symbol

func SplitAndTrim added in v1.10.0 

func SplitAndTrim(input string) []string

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

func StartNode 

func StartNode(stack *node.Node)

func ToCamelCase 

func ToCamelCase(inputUnderScoreStr string) (camelCase string)

ToCamelCase converts an under-score string to a camel-case string

func ToHyphen 

func ToHyphen(s string) string

ToHyphen converts a camel-case string to a hyphen-style string

func ToUnderScore 

func ToUnderScore(s string) string

ToUnderScore converts a camel-case string to a under-score string

func WriteFile 

func WriteFile(content, filePath, fileName string)

Types

type BigFlag 

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

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

func (BigFlag) Apply 

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

func (BigFlag) GetName 

func (f BigFlag) GetName() string

func (BigFlag) String 

func (f BigFlag) String() string

type DirectoryFlag 

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

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

func (DirectoryFlag) Apply 

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

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

func (DirectoryFlag) GetName 

func (self DirectoryFlag) GetName() string

func (*DirectoryFlag) Set 

func (self *DirectoryFlag) Set(value string)

func (DirectoryFlag) String 

func (self DirectoryFlag) String() string

type DirectoryString 

type DirectoryString struct {
	Value string
}

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

func (*DirectoryString) Set 

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

func (*DirectoryString) String 

func (self *DirectoryString) String() string

type FlagGroup 

type FlagGroup struct {
	Name  string
	Flags []cli.Flag
}

FlagGroup is a collection of flags belonging to a single topic.

func CategorizeFlags added in v1.5.3 

func CategorizeFlags(flags []cli.Flag) []FlagGroup

CategorizeFlags classifies each flag into pre-defined flagGroups.

type KlayConfig added in v1.10.0 

type KlayConfig struct {
	CN               cn.Config
	Node             node.Config
	DB               dbsyncer.DBConfig
	ChainDataFetcher chaindatafetcher.ChainDataFetcherConfig
	ServiceChain     sc.SCConfig
}

func MakeConfigNode added in v1.10.0 

func MakeConfigNode(ctx *cli.Context) (*node.Node, KlayConfig)

func (*KlayConfig) SetChainDataFetcherConfig added in v1.10.0 

func (kCfg *KlayConfig) SetChainDataFetcherConfig(ctx *cli.Context)

func (*KlayConfig) SetDBSyncerConfig added in v1.10.0 

func (kCfg *KlayConfig) SetDBSyncerConfig(ctx *cli.Context)

func (*KlayConfig) SetKlayConfig added in v1.10.0 

func (kCfg *KlayConfig) SetKlayConfig(ctx *cli.Context, stack *node.Node)

setKlayConfig applies klay-related command line flags to the config.

func (*KlayConfig) SetNodeConfig added in v1.10.0 

func (kCfg *KlayConfig) SetNodeConfig(ctx *cli.Context)

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

func (*KlayConfig) SetServiceChainConfig added in v1.10.0 

func (kCfg *KlayConfig) SetServiceChainConfig(ctx *cli.Context)

type TestCmd 

type TestCmd struct {
	// For total convenience, all testing methods are available.
	*testing.T

	Func    template.FuncMap
	Data    interface{}
	Cleanup func()
	// contains filtered or unexported fields
}

func NewTestCmd 

func NewTestCmd(t *testing.T, data interface{}) *TestCmd

func (*TestCmd) CloseStdin 

func (tt *TestCmd) CloseStdin()

func (*TestCmd) Expect 

func (tt *TestCmd) Expect(tplsource string)

Expect runs its argument as a template, then expects the child process to output the result of the template within 5s.

If the template starts with a newline, the newline is removed before matching.

func (*TestCmd) ExpectExit 

func (tt *TestCmd) ExpectExit()

ExpectExit expects the child process to exit within 5s without printing any additional text on stdout.

func (*TestCmd) ExpectRegexp 

func (tt *TestCmd) ExpectRegexp(regex string) (*regexp.Regexp, []string)

ExpectRegexp expects the child process to output text matching the given regular expression within 5s.

Note that an arbitrary amount of output may be consumed by the regular expression. This usually means that expect cannot be used after ExpectRegexp.

func (*TestCmd) InputLine 

func (tt *TestCmd) InputLine(s string) string

InputLine writes the given text to the childs stdin. This method can also be called from an expect template, e.g.: 

klay.expect(`Passphrase: {{.InputLine "password"}}`)

func (*TestCmd) Interrupt 

func (tt *TestCmd) Interrupt()

func (*TestCmd) Kill 

func (tt *TestCmd) Kill()

func (*TestCmd) Run 

func (tt *TestCmd) Run(name string, args ...string)

Run exec's the current binary using name as argv[0] which will trigger the reexec init function for that name (e.g. "klay-test" in cmd/utils/nodecmd/run_test.go)

func (*TestCmd) SetTemplateFunc 

func (tt *TestCmd) SetTemplateFunc(name string, fn interface{})

func (*TestCmd) StderrText 

func (tt *TestCmd) StderrText() string

StderrText returns any stderr output written so far. The returned text holds all log lines after ExpectExit has returned.

func (*TestCmd) WaitExit 

func (tt *TestCmd) WaitExit()

type TextMarshaler 

type TextMarshaler interface {
	encoding.TextMarshaler
	encoding.TextUnmarshaler
}

func GlobalTextMarshaler 

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

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

type TextMarshalerFlag 

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

TextMarshalerFlag wraps a TextMarshaler value.

func (TextMarshalerFlag) Apply 

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

func (TextMarshalerFlag) GetName 

func (f TextMarshalerFlag) GetName() string

func (TextMarshalerFlag) String 

func (f TextMarshalerFlag) String() string

type WrappedDirectoryFlag added in v1.9.1 

type WrappedDirectoryFlag struct {
	DirectoryFlag
	// contains filtered or unexported fields
}

func NewWrappedDirectoryFlag added in v1.9.1 

func NewWrappedDirectoryFlag(fl DirectoryFlag) *WrappedDirectoryFlag

func (*WrappedDirectoryFlag) Apply added in v1.9.1 

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

func (*WrappedDirectoryFlag) ApplyInputSourceValue added in v1.9.1 

func (f *WrappedDirectoryFlag) ApplyInputSourceValue(context *cli.Context, isc altsrc.InputSourceContext) error

type WrappedTextMarshalerFlag added in v1.9.1 

type WrappedTextMarshalerFlag struct {
	TextMarshalerFlag
	// contains filtered or unexported fields
}

func NewWrappedTextMarshalerFlag added in v1.9.1 

func NewWrappedTextMarshalerFlag(fl TextMarshalerFlag) *WrappedTextMarshalerFlag

func (*WrappedTextMarshalerFlag) Apply added in v1.9.1 

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

func (*WrappedTextMarshalerFlag) ApplyInputSourceValue added in v1.9.1 

func (f *WrappedTextMarshalerFlag) ApplyInputSourceValue(context *cli.Context, isc altsrc.InputSourceContext) error

Source Files

View all Source files

Directories

Path Synopsis
Package nodecmd contains command definitions and related functions used for node cmds, such as kcn, kpn, and ken.
 Package nodecmd contains command definitions and related functions used for node cmds, such as kcn, kpn, and ken.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.