mmgen/base_obj.py

@@ -59,7 +59,7 @@ class AttrCtrl(metaclass=AttrCtrlMeta):
 		if self._locked and self._default_to_none:
 			return None
 		else:
-			raise AttributeError(f'{type(self).__name__} object has no attribute {name!r}')
+			raise AttributeError(f'{self} has no attribute {name!r}')
 
 	def __setattr__(self, name, value):
 

mmgen/cfg.py

@@ -35,7 +35,7 @@ def die2(exit_val, s):
 class GlobalConstants(Lockable):
 	"""
 	These values are non-runtime-configurable.  They’re constant for a given machine,
-	user, executable and MMGen release.
+	user, executable and MMGen Wallet version
 	"""
 	_autolock = True
 
@@ -280,6 +280,8 @@ class Config(Lockable):
 		('autosign', 'outdir'),
 	)
 
+	# proto-specific only: eth_mainnet_chain_names eth_testnet_chain_names
+	# coin-specific only:  bch_cashaddr (alias of cashaddr)
 	_cfg_file_opts = (
 		'autochg_ignore_labels',
 		'color',
@@ -289,6 +291,7 @@ class Config(Lockable):
 		'force_256_color',
 		'hash_preset',
 		'http_timeout',
+		'ignore_daemon_version', # also coin-specific
 		'macos_autosign_ramdisk_size',
 		'max_input_size',
 		'max_tx_file_size',
@@ -298,27 +301,15 @@ class Config(Lockable):
 		'no_license',
 		'quiet',
 		'regtest',
-		'rpc_host',
-		'rpc_password',
-		'rpc_port',
-		'rpc_user',
+		'rpc_host',     # also coin-specific
+		'rpc_password', # also coin-specific
+		'rpc_port',     # also coin-specific
+		'rpc_user',     # also coin-specific
 		'scroll',
 		'subseeds',
 		'testnet',
-		'usr_randchars',
-		'bch_cashaddr',
-		'bch_max_tx_fee',
-		'btc_max_tx_fee',
-		'eth_max_tx_fee',
-		'ltc_max_tx_fee',
-		'bch_ignore_daemon_version',
-		'btc_ignore_daemon_version',
-		'etc_ignore_daemon_version',
-		'eth_ignore_daemon_version',
-		'ltc_ignore_daemon_version',
-		'xmr_ignore_daemon_version',
-		'eth_mainnet_chain_names',
-		'eth_testnet_chain_names')
+		'tw_name',      # also coin-specific
+		'usr_randchars')
 
 	# Supported environmental vars
 	# The corresponding attributes (lowercase, without 'mmgen_') must exist in the class.
@@ -367,6 +358,7 @@ class Config(Lockable):
 		'MMGEN_ENABLE_ERIGON',
 		'MMGEN_DISABLE_COLOR',
 	)
+
 	_infile_opts = (
 		'keys_from_file',
 		'mmgen_keys_from_file',
@@ -375,6 +367,7 @@ class Config(Lockable):
 		'comment_file',
 		'contract_data',
 	)
+
 	# Auto-typechecked and auto-set opts - first value in list is the default
 	_ov = namedtuple('autoset_opt_info', ['type', 'choices'])
 	_autoset_opts = {
@@ -465,7 +458,7 @@ class Config(Lockable):
 				opt_filter   = opt_filter,
 				parsed_opts  = parsed_opts,
 				need_proto   = need_proto)
-			self._uopt_desc = 'command-line option'
+			self._uopt_src = 'cmdline'
 		else:
 			if cfg is None:
 				self._uopts = {}
@@ -478,7 +471,7 @@ class Config(Lockable):
 							setattr(self, k, v)
 					del cfg['_clone']
 				self._uopts = cfg
-			self._uopt_desc = 'configuration option'
+			self._uopt_src = 'cfg'
 
 		self._data_dir_root_override = self._cloned.pop(
 			'_data_dir_root_override',
@@ -501,7 +494,7 @@ class Config(Lockable):
 						self,
 						key,
 						getattr(type(self), key) if val is None else
-							conv_type(key, val, getattr(type(self), key), self._uopt_desc))
+							conv_type(key, val, getattr(type(self), key), src=self._uopt_src))
 				elif val is None:
 					if hasattr(self, key):
 						delattr(self, key)
@@ -561,6 +554,9 @@ class Config(Lockable):
 
 		del self._cloned
 
+		if hasattr(self, 'bch_cashaddr') and not hasattr(self, 'cashaddr'):
+			self.cashaddr = self.bch_cashaddr
+
 		self._lock()
 
 		if need_proto:
@@ -602,7 +598,7 @@ class Config(Lockable):
 						setattr(
 							self,
 							gname,
-							conv_type(name, val, getattr(self, gname), 'environment var', invert_bool=disable))
+							conv_type(name, val, getattr(self, gname), src='env', invert_bool=disable))
 						yield gname
 					else:
 						raise ValueError(f'Name {gname!r} not present in globals')
@@ -632,34 +628,29 @@ class Config(Lockable):
 		non_auto_opts = []
 		already_set = tuple(self._uopts) + env_cfg
 
+		def set_opt(d, obj, name, refval):
+			val = ucfg.parse_value(d.value, refval)
+			if not val:
+				die('CfgFileParseError', f'Parse error in file {ucfg.fn!r}, line {d.lineno}')
+			val_conv = conv_type(name, val, refval, src=ucfg.fn)
+			setattr(obj, name, val_conv)
+			non_auto_opts.append(name)
+
 		for d in ucfg.get_lines():
 			if d.name in self._cfg_file_opts:
-				ns = d.name.split('_')
-				if ns[0] in gc.core_coins:
-					if not need_proto:
-						continue
-					nse, tn = (
-						(ns[2:], ns[1]=='testnet') if len(ns) > 2 and ns[1] in ('mainnet', 'testnet') else
-						(ns[1:], False)
-					)
-					# no instance yet, so override _class_ attr:
-					cls = init_proto(self, ns[0], tn, need_amt=True, return_cls=True)
-					attr = '_'.join(nse)
-				else:
-					cls = self
-					attr = d.name
-				refval = getattr(cls, attr)
-				val = ucfg.parse_value(d.value, refval)
-				if not val:
-					die('CfgFileParseError', f'Parse error in file {ucfg.fn!r}, line {d.lineno}')
-				val_conv = conv_type(attr, val, refval, 'configuration file option', src=ucfg.fn)
-				if not attr in already_set:
-					setattr(cls, attr, val_conv)
-					non_auto_opts.append(attr)
+				if not d.name in already_set:
+					set_opt(d, self, d.name, getattr(self, d.name))
 			elif d.name in self._autoset_opts:
 				autoset_opts[d.name] = d.value
 			elif d.name in self._auto_typeset_opts:
 				auto_typeset_opts[d.name] = d.value
+			elif any(d.name.startswith(coin + '_') for coin in gc.rpc_coins):
+				if need_proto and not d.name in already_set:
+					try:
+						refval = init_proto(self, d.name.split('_', 1)[0]).get_opt_clsval(self, d.name)
+					except AttributeError:
+						die('CfgFileParseError', f'{d.name!r}: unrecognized option in {ucfg.fn!r}, line {d.lineno}')
+					set_opt(d, self, d.name, refval)
 			else:
 				die('CfgFileParseError', f'{d.name!r}: unrecognized option in {ucfg.fn!r}, line {d.lineno}')
 
@@ -753,7 +744,7 @@ def check_opts(cfg): # Raises exception if any check fails
 			(desc_pfx + ' ' if desc_pfx else '')
 			+ (
 				f'parameter for command-line option {fmt_opt(name)!r}'
-					if name in cfg._uopts and 'command-line' in cfg._uopt_desc else
+					if name in cfg._uopts and cfg._uopt_src == 'cmdline' else
 				f'value for configuration option {name!r}'
 			)
 			+ (' from environment' if name in cfg._envopts else '')
@@ -929,23 +920,23 @@ def opt_postproc_debug(cfg):
 	Msg('        {}\n'.format('\n        '.join(none_opts)))
 	Msg('\n=== end opts.py debug ===\n')
 
-def conv_type(
-		name,
-		val,
-		refval,
-		desc,
-		invert_bool = False,
-		src         = None):
+def conv_type(name, val, refval, src, invert_bool=False):
 
 	def do_fail():
-		die(1, '{a!r}: invalid value for {b} {c!r}{d} (must be of type {e!r})'.format(
+		desc = {
+			'cmdline': 'command-line',
+			'cfg':     'Config',
+			'env':     'environment var',
+		}
+		die(1, '{a!r}: invalid value for {b} option {c!r}{d} (must be of type {e!r})'.format(
 			a = val,
-			b = desc,
-			c = fmt_opt(name) if 'command-line' in desc else name,
-			d = f' in {src!r}' if src else '',
+			b = desc.get(src, 'config file'),
+			c = fmt_opt(name) if src == 'cmdline' else name,
+			d = '' if src in ('cmdline', 'cfg', 'env') else f' in {src!r}',
 			e = type(refval).__name__))
 
-	if type(refval) is bool:
+	# refval is None = boolean opt with no cmdline parameter
+	if type(refval) is bool or refval is None:
 		v = str(val).lower()
 		ret = (
 			True  if v in ('true', 'yes', '1', 'on') else
@@ -953,6 +944,12 @@ def conv_type(
 			None
 		)
 		return do_fail() if ret is None else (not ret) if invert_bool else ret
+	elif isinstance(refval, (list, tuple)):
+		if src == 'cmdline':
+			return type(refval)(val.split(','))
+		else:
+			assert isinstance(val, (list, tuple)), f'{val}: not a list or tuple'
+			return type(refval)(val)
 	else:
 		try:
 			return type(refval)(not val if invert_bool else val)

mmgen/cfgfile.py

@@ -254,15 +254,17 @@ class CfgFileSampleUsr(cfg_file_sample):
 	def show_changes(self, diff):
 		ymsg('Warning: configuration file options have changed!\n')
 		for desc in ('added', 'removed'):
-			data = diff[desc]
-			if data:
-				opts = fmt_list([i.name for i in data], fmt='bare')
-				msg(f'  The following option{suf(data, verb="has")} been {desc}:\n    {opts}\n')
-				if desc == 'removed' and data:
+			changed_opts = [i.name for i in diff[desc]
+				# workaround for coin-specific opts previously listed in sample file:
+				if not (i.name.endswith('_ignore_daemon_version') and desc == 'removed')
+			]
+			if changed_opts:
+				msg(f'  The following option{suf(changed_opts, verb="has")} been {desc}:')
+				msg(f'    {fmt_list(changed_opts, fmt="bare")}\n')
+				if desc == 'removed':
 					uc = mmgen_cfg_file(self.cfg, 'usr')
 					usr_names = [i.name for i in uc.get_lines()]
-					rm_names = [i.name for i in data]
-					bad = sorted(set(usr_names).intersection(rm_names))
+					bad = sorted(set(usr_names).intersection(changed_opts))
 					if bad:
 						m = f"""
 							The following removed option{suf(bad, verb='is')} set in {uc.fn!r}

mmgen/daemon.py

@@ -420,7 +420,8 @@ class CoinDaemon(Daemon):
 		ps_adj = (port_shift or 0) + (self.test_suite_port_shift if test_suite else 0)
 
 		# user-set values take precedence
-		self.rpc_port = (cfg.rpc_port or 0) + (port_shift or 0) if cfg.rpc_port else ps_adj + self.get_rpc_port()
+		usr_rpc_port = self.proto.rpc_port or cfg.rpc_port
+		self.rpc_port = usr_rpc_port + (port_shift or 0) if usr_rpc_port else ps_adj + self.get_rpc_port()
 		self.p2p_port = (
 			p2p_port or (
 				self.get_p2p_port() + ps_adj if self.get_p2p_port() and (test_suite or ps_adj) else None

mmgen/data/mmgen.cfg

@@ -26,18 +26,6 @@
 # Uncomment to use testnet instead of mainnet:
 # testnet true
 
-# Set the RPC host (the host the coin daemon is running on):
-# rpc_host localhost
-
-# Set the RPC host's port number:
-# rpc_port 8332
-
-# Uncomment to override 'rpcuser' from coin daemon config file:
-# rpc_user myusername
-
-# Uncomment to override 'rpcpassword' from coin daemon config file:
-# rpc_password mypassword
-
 # Choose the backend to use for JSON-RPC connections.  Valid choices:
 # 'auto' (defaults to 'httplib'), 'httplib', 'requests', 'curl', 'aiohttp':
 # rpc_backend auto
@@ -89,27 +77,44 @@
 # setups with unusually large Monero wallets:
 # macos_autosign_ramdisk_size 10
 
-############################
-## Ignore daemon versions ##
-############################
+# Ignore coin daemon version. This option also has coin-specific variants
+# (see below):
+# ignore_daemon_version false
+
+# Specify the tracking wallet name. This option also has coin-specific
+# variants (see below):
+# tw_name my-other-tracking-wallet
 
-# Ignore Bitcoin Core version:
-# btc_ignore_daemon_version false
+#####################################################################
+## RPC options. These also have coin-specific variants (see below) ##
+#####################################################################
 
-# Ignore Litecoin Core version:
-# ltc_ignore_daemon_version false
+# Set the RPC host (the host the coin daemon is running on):
+# rpc_host localhost
 
-# Ignore Bitcoin Cash Node version:
-# bch_ignore_daemon_version false
+# Set the RPC host's port number:
+# rpc_port 8332
 
-# Ignore OpenEthereum version for ETH:
-# eth_ignore_daemon_version false
+# Uncomment to override 'rpcuser' from coin daemon config file:
+# rpc_user myusername
 
-# Ignore OpenEthereum version for ETC:
-# etc_ignore_daemon_version false
+# Uncomment to override 'rpcpassword' from coin daemon config file:
+# rpc_password mypassword
 
-# Ignore daemon version for Monero:
-# xmr_ignore_daemon_version false
+#######################################################################
+#######################  COIN-SPECIFIC OPTIONS  #######################
+#######################################################################
+##     OPTION                   SUPPORTED PREFIXES                   ##
+##     tw_name                  btc ltc bch                          ##
+##     rpc_user                 btc ltc bch                          ##
+##     rpc_password             btc ltc bch                          ##
+##     rpc_host                 btc ltc bch eth etc                  ##
+##     rpc_port                 btc ltc bch eth etc xmr              ##
+##     ignore_daemon_version    btc ltc bch eth etc xmr              ##
+##     max_tx_fee               btc ltc bch eth etc                  ##
+## Note: prefix is followed by an underscore, e.g. ‘xmr_rpc_port’    ##
+#######################################################################
+#######################################################################
 
 #####################
 ## Altcoin options ##
@@ -139,7 +144,6 @@
 # Set the Monero wallet RPC password to something secure:
 # monero_wallet_rpc_password passw0rd
 
-
 #######################################################################
 ## The following options are probably of interest only to developers ##
 #######################################################################

mmgen/data/version

@@ -1 +1 @@
-15.1.dev11
+15.1.dev12

mmgen/help/__init__.py

@@ -62,7 +62,7 @@ def usage(cfg):
 
 class Help:
 
-	def make(self, cfg, opts, proto):
+	def make(self, cfg, opts):
 
 		def gen_arg_tuple(func, text):
 
@@ -86,27 +86,28 @@ class Help:
 				yield d[arg] if arg in d else text
 
 		def gen_output():
-			yield '  {} {}'.format(gc.prog_name.upper() + ':', text['desc'].strip())
+			yield '  {} {}'.format(gc.prog_name.upper() + ':', opts.opts_data['text']['desc'].strip())
 			yield make_usage_str(cfg, caller='help')
-			yield help_type.upper().replace('_', ' ') + ':'
+			yield self.help_type.upper().replace('_', ' ') + ':'
 
 			# process code for options
 			opts_text = nl.join(self.gen_text(opts))
-			if help_type in code:
-				yield code[help_type](*tuple(gen_arg_tuple(code[help_type], opts_text)))
+			if 'options' in code:
+				yield code['options'](*tuple(gen_arg_tuple(code['options'], opts_text)))
 			else:
 				yield opts_text
 
 			# process code for notes
-			if help_type == 'options' and 'notes' in text:
+			if 'notes' in text:
 				if 'notes' in code:
 					yield from code['notes'](*tuple(gen_arg_tuple(code['notes'], text['notes']))).splitlines()
 				else:
 					yield from text['notes'].splitlines()
 
-		text = opts.opts_data['text']
-		code = opts.opts_data['code']
-		help_type = self.help_type
+		from ..protocol import init_proto_from_cfg
+		proto = init_proto_from_cfg(cfg, need_amt=True)
+		text = getattr(opts, self.data_desc)['text']
+		code = getattr(opts, self.data_desc)['code']
 		nl = '\n  '
 
 		return nl.join(gen_output()) + '\n'
@@ -114,6 +115,7 @@ class Help:
 class CmdHelp(Help):
 
 	help_type = 'options'
+	data_desc = 'opts_data'
 
 	def gen_text(self, opts):
 		opt_filter = opts.opt_filter
@@ -137,33 +139,27 @@ class CmdHelp(Help):
 class GlobalHelp(Help):
 
 	help_type = 'global_options'
+	data_desc = 'global_opts_data'
 
 	def gen_text(self, opts):
-		from ..opts import global_opts_pat
-		for line in opts.global_opts_data['text'][1:-2].splitlines():
-			if m := global_opts_pat.match(line):
-				if m[1] in opts.global_opts_filter.coin and m[2] in opts.global_opts_filter.cmd:
-					yield '  --{} {}'.format(m[3], m[5])
-					skipping = False
-				else:
-					skipping = True
-			elif not skipping:
-				yield line[4:]
+		from ..opts import global_opts_help_pat
+		skipping = False
+		for line in opts.global_opts_data['text']['options'][1:-3].splitlines():
+			m = global_opts_help_pat.match(line)
+			if m[1] == '+':
+				if not skipping:
+					yield line[4:]
+			elif m[1] in opts.global_opts_filter.coin and m[2] in opts.global_opts_filter.cmd:
+				yield '  --{} {}'.format(m[3], m[5]) if m[3] else m[5]
+				skipping = False
+			else:
+				skipping = True
 
 def print_help(cfg, opts):
 
-	from ..protocol import init_proto_from_cfg
-	proto = init_proto_from_cfg(cfg, need_amt=True)
-
 	if not 'code' in opts.opts_data:
 		opts.opts_data['code'] = {}
 
-	if cfg.help:
-		cls = CmdHelp
-	else:
-		opts.opts_data['code']['global_options'] = opts.global_opts_data['code']
-		cls = GlobalHelp
-
 	from ..ui import do_pager
-	do_pager(cls().make(cfg, opts, proto))
+	do_pager((CmdHelp if cfg.help else GlobalHelp)().make(cfg, opts))
 	sys.exit(0)

mmgen/opts.py

@@ -43,7 +43,7 @@ def get_opt_by_substring(opt, opts):
 		from .util import die
 		die('CmdlineOptError', f'--{opt}: ambiguous option (not unique substring)')
 
-def process_uopts(opts_data, opts):
+def process_uopts(cfg, opts_data, opts, need_proto):
 
 	from .util import die
 
@@ -83,6 +83,32 @@ def process_uopts(opts_data, opts):
 					if parm:
 						die('CmdlineOptError', f'option --{_opt} requires no parameter')
 					yield (negated_opts(opts)[_opt].name, False)
+				elif (
+						need_proto
+						and (not gc.cmd_caps or gc.cmd_caps.rpc)
+						and any(opt.startswith(coin + '-') for coin in gc.rpc_coins)):
+					opt_name = opt.replace('-', '_')
+					from .protocol import init_proto
+					try:
+						refval = init_proto(cfg, opt.split('-', 1)[0], return_cls=True).get_opt_clsval(cfg, opt_name)
+					except AttributeError:
+						die('CmdlineOptError', f'--{opt}: unrecognized option')
+					else:
+						if refval is None: # None == no parm
+							if parm:
+								die('CmdlineOptError', f'option --{opt} requires no parameter')
+							yield (opt_name, True)
+						else:
+							from .cfg import conv_type
+							if parm:
+								yield (opt_name,
+									conv_type(opt_name, parm, refval, src='cmdline'))
+							else:
+								idx += 1
+								if idx == argv_len or (parm := sys.argv[idx]).startswith('-'):
+									die('CmdlineOptError', f'missing parameter for option --{opt}')
+								yield (opt_name,
+									conv_type(opt_name, parm, refval, src='cmdline'))
 				else:
 					die('CmdlineOptError', f'--{opt}: unrecognized option')
 			elif arg[0] == '-' and len(arg) > 1:
@@ -125,10 +151,11 @@ def process_uopts(opts_data, opts):
 	return uopts, uargs
 
 cmd_opts_pat = re.compile(r'^-([a-zA-Z0-9-]), --([a-zA-Z0-9-]{2,64})(=| )(.+)')
-global_opts_pat = re.compile(r'^\t\t\t(.)(.) --([a-zA-Z0-9-]{2,64})(=| )(.+)')
+global_opts_pat = re.compile(r'^\t\t\t(.)(.) --([a-z0-9-]{2,64})(=| )(.+)')
+global_opts_help_pat = re.compile(r'^\t\t\t(.)(.) (?:--([{}a-zA-Z0-9-]{2,64})(=| ))?(.+)')
 opt_tuple = namedtuple('cmdline_option', ['name', 'has_parm'])
 
-def parse_opts(opts_data, opt_filter, global_opts_data, global_opts_filter):
+def parse_opts(cfg, opts_data, opt_filter, global_opts_data, global_opts_filter, need_proto):
 
 	def parse_cmd_opts_text():
 		for line in opts_data['text']['options'].strip().splitlines():
@@ -139,14 +166,14 @@ def parse_opts(opts_data, opt_filter, global_opts_data, global_opts_filter):
 				yield (m[2], ret)
 
 	def parse_global_opts_text():
-		for line in global_opts_data['text'].splitlines():
+		for line in global_opts_data['text']['options'].splitlines():
 			m = global_opts_pat.match(line)
 			if m and m[1] in global_opts_filter.coin and m[2] in global_opts_filter.cmd:
 				yield (m[3], opt_tuple(m[3].replace('-', '_'), m[4] == '='))
 
 	opts = tuple(parse_cmd_opts_text()) + tuple(parse_global_opts_text())
 
-	uopts, uargs = process_uopts(opts_data, dict(opts))
+	uopts, uargs = process_uopts(cfg, opts_data, dict(opts), need_proto)
 
 	return namedtuple('parsed_cmd_opts', ['user_opts', 'cmd_args', 'opts'])(
 		uopts, # dict
@@ -213,7 +240,13 @@ class Opts:
 		self.global_opts_filter = self.get_global_opts_filter(need_proto)
 		self.opts_data = opts_data
 
-		po = parsed_opts or parse_opts(opts_data, opt_filter, self.global_opts_data, self.global_opts_filter)
+		po = parsed_opts or parse_opts(
+			cfg,
+			opts_data,
+			opt_filter,
+			self.global_opts_data,
+			self.global_opts_filter,
+			need_proto)
 
 		cfg._args = po.cmd_args
 		cfg._uopts = uopts = po.user_opts
@@ -245,7 +278,8 @@ class UserOpts(Opts):
 
 	global_opts_data = {
 		#  coin code : cmd code : opt : opt param : text
-		'text': """
+		'text': {
+			'options': """
 			-- --accept-defaults      Accept defaults at all prompts
 			hp --cashaddr=0|1         Display addresses in cashaddr format (default: 1)
 			-p --coin=c               Choose coin unit. Default: BTC. Current choice: {cu_dfl}
@@ -262,10 +296,10 @@ class UserOpts(Opts):
 			rr --ignore-daemon-version Ignore coin daemon version check
 			rr --http-timeout=t       Set HTTP timeout in seconds for JSON-RPC connections
 			-- --no-license           Suppress the GPL license prompt
-			rr --rpc-host=HOST        Communicate with coin daemon running on host HOST
+			Rr --rpc-host=HOST        Communicate with coin daemon running on host HOST
 			rr --rpc-port=PORT        Communicate with coin daemon listening on port PORT
-			rr --rpc-user=USER        Authenticate to coin daemon using username USER
-			rr --rpc-password=PASS    Authenticate to coin daemon using password PASS
+			br --rpc-user=USER        Authenticate to coin daemon using username USER
+			br --rpc-password=PASS    Authenticate to coin daemon using password PASS
 			Rr --rpc-backend=backend  Use backend 'backend' for JSON-RPC communications
 			Rr --aiohttp-rpc-queue-len=N Use N simultaneous RPC connections with aiohttp
 			-p --regtest=0|1          Disable or enable regtest mode
@@ -278,11 +312,28 @@ class UserOpts(Opts):
 			b- --bob                  Specify user ‘Bob’ in MMGen regtest mode
 			b- --alice                Specify user ‘Alice’ in MMGen regtest mode
 			b- --carol                Specify user ‘Carol’ in MMGen regtest mode
-		""",
-		'code': lambda proto, help_notes, s: s.format(
-			pnm     = gc.proj_name,
-			cu_dfl  = proto.coin,
-			tw_name = help_notes('dfl_twname'))
+			rr COIN-SPECIFIC OPTIONS:
+			rr   For descriptions, refer to the non-prefixed versions of these options above
+			rr   Prefixed options override their non-prefixed counterparts
+			rr   OPTION                            SUPPORTED PREFIXES
+			rr --PREFIX-ignore-daemon-version    btc ltc bch eth etc xmr
+			br --PREFIX-tw-name                  btc ltc bch
+			Rr --PREFIX-rpc-host                 btc ltc bch eth etc
+			rr --PREFIX-rpc-port                 btc ltc bch eth etc xmr
+			br --PREFIX-rpc-user                 btc ltc bch
+			br --PREFIX-rpc-password             btc ltc bch
+			Rr --PREFIX-max-tx-fee               btc ltc bch eth etc
+			Rr PROTO-SPECIFIC OPTIONS:
+			Rr   Option                            Supported Prefixes
+			Rr --PREFIX-chain-names              eth-mainnet eth-testnet etc-mainnet etc-testnet
+			""",
+		},
+		'code': {
+			'options': lambda proto, help_notes, s: s.format(
+				pnm     = gc.proj_name,
+				cu_dfl  = proto.coin,
+				tw_name = help_notes('dfl_twname')),
+		}
 	}
 
 	@staticmethod

mmgen/proto/bch/params.py

@@ -27,8 +27,7 @@ class mainnet(mainnet):
 	]
 	caps = ()
 	coin_amt        = 'BCHAmt'
-	max_tx_fee      = '0.1'
-	ignore_daemon_version = False
+	max_tx_fee      = 0.1
 	cashaddr_pfx    = 'bitcoincash'
 	cashaddr        = True
 

mmgen/proto/btc/params.py

@@ -28,7 +28,7 @@ class mainnet(CoinProtocol.Secp256k1): # chainparams.cpp
 	mmtypes         = ('L', 'C', 'S', 'B')
 	dfl_mmtype      = 'L'
 	coin_amt        = 'BTCAmt'
-	max_tx_fee      = '0.003'
+	max_tx_fee      = 0.003
 	sighash_type    = 'ALL'
 	block0          = '000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f'
 	forks           = [
@@ -50,9 +50,19 @@ class mainnet(CoinProtocol.Secp256k1): # chainparams.cpp
 	diff_adjust_interval = 2016
 	max_halvings    = 64
 	start_subsidy   = 50
-	ignore_daemon_version = False
 	max_int         = 0xffffffff
 
+	coin_cfg_opts = (
+		'ignore_daemon_version',
+		'rpc_host',
+		'rpc_port',
+		'rpc_user',
+		'rpc_password',
+		'tw_name',
+		'max_tx_fee',
+		'cashaddr',
+	)
+
 	def encode_wif(self, privbytes, pubkey_type, compressed): # input is preprocessed hex
 		assert len(privbytes) == self.privkey_len, f'{len(privbytes)} bytes: incorrect private key length!'
 		assert pubkey_type in self.wif_ver_bytes, f'{pubkey_type!r}: invalid pubkey_type'

mmgen/proto/btc/rpc.py

@@ -124,11 +124,13 @@ class BitcoinRPCClient(RPCClient, metaclass=AsyncInit):
 		self.proto = proto
 		self.daemon = daemon
 		self.call_sigs = getattr(CallSigs, daemon.id)(cfg)
-		self.twname = TrackingWalletName(cfg.regtest_user or cfg.tw_name or self.dfl_twname)
+		self.twname = TrackingWalletName(cfg.regtest_user or proto.tw_name or cfg.tw_name or self.dfl_twname)
 
 		super().__init__(
 			cfg  = cfg,
-			host = 'localhost' if cfg.test_suite or cfg.network == 'regtest' else (cfg.rpc_host or 'localhost'),
+			host = (
+				'localhost' if cfg.test_suite or cfg.network == 'regtest'
+				else (proto.rpc_host or cfg.rpc_host or 'localhost')),
 			port = daemon.rpc_port)
 
 		self.set_auth()
@@ -210,29 +212,28 @@ class BitcoinRPCClient(RPCClient, metaclass=AsyncInit):
 		"""
 		if self.cfg.network == 'regtest':
 			from .regtest import MMGenRegtest
-			user, passwd = (MMGenRegtest.rpc_user, MMGenRegtest.rpc_password)
-		elif self.cfg.rpc_user:
-			user, passwd = (self.cfg.rpc_user, self.cfg.rpc_password)
+			user = MMGenRegtest.rpc_user
+			passwd = MMGenRegtest.rpc_password
 		else:
-			user, passwd = self.get_daemon_cfg_options(('rpcuser', 'rpcpassword')).values()
-
-		if not (user and passwd):
-			user, passwd = (self.daemon.rpc_user, self.daemon.rpc_password)
+			user = (
+				self.proto.rpc_user or self.cfg.rpc_user or self.get_daemon_cfg_option('rpcuser')
+				or self.daemon.rpc_user)
+			passwd = (
+				self.proto.rpc_password or self.cfg.rpc_password or self.get_daemon_cfg_option('rpcpassword')
+				or self.daemon.rpc_password)
 
 		if user and passwd:
 			self.auth = auth_data(user, passwd)
 			return
 
 		if self.has_auth_cookie:
-			cookie = self.get_daemon_auth_cookie()
-			if cookie:
+			if cookie := self.get_daemon_auth_cookie():
 				self.auth = auth_data(*cookie.split(':'))
 				return
 
 		die(1, '\n\n' + fmt(no_credentials_errmsg, strip_char='\t', indent='  ').format(
-				proto_name = self.proto.name,
-				cf_name = (self.proto.is_fork_of or self.proto.name).lower(),
-			))
+			proto_name = self.proto.name,
+			cf_name = (self.proto.is_fork_of or self.proto.name).lower()))
 
 	def make_host_path(self, wallet):
 		return f'/wallet/{wallet}' if wallet else self.wallet_path
@@ -262,6 +263,9 @@ class BitcoinRPCClient(RPCClient, metaclass=AsyncInit):
 			(os.path.dirname(self.cfg.data_dir) if self.proto.regtest else self.daemon.datadir),
 			self.daemon.cfg_file)
 
+	def get_daemon_cfg_option(self, req_key):
+		return list(self.get_daemon_cfg_options([req_key]).values())[0]
+
 	def get_daemon_cfg_options(self, req_keys):
 
 		fn = self.get_daemon_cfg_fn()

mmgen/proto/etc/params.py

@@ -16,9 +16,8 @@ from ..eth.params import mainnet
 
 class mainnet(mainnet):
 	chain_names = ['classic', 'ethereum_classic']
-	max_tx_fee  = '0.005'
+	max_tx_fee  = 0.005
 	coin_amt    = 'ETCAmt'
-	ignore_daemon_version = False
 
 class testnet(mainnet):
 	chain_names = ['morden', 'morden_testnet', 'classic-testnet']

mmgen/proto/eth/params.py

@@ -26,7 +26,7 @@ class mainnet(CoinProtocol.DummyWIF, CoinProtocol.Secp256k1):
 	pubkey_type   = 'std' # required by DummyWIF
 
 	coin_amt      = 'ETHAmt'
-	max_tx_fee    = '0.005'
+	max_tx_fee    = 0.005
 	chain_names   = ['ethereum', 'foundation']
 	sign_mode     = 'standalone'
 	caps          = ('token',)
@@ -35,7 +35,6 @@ class mainnet(CoinProtocol.DummyWIF, CoinProtocol.Secp256k1):
 	base_proto_coin = 'ETH'
 	base_coin     = 'ETH'
 	avg_bdi       = 15
-	ignore_daemon_version = False
 	decimal_prec  = 36
 
 	chain_ids = {
@@ -52,6 +51,17 @@ class mainnet(CoinProtocol.DummyWIF, CoinProtocol.Secp256k1):
 		711:  'ethereum',         # geth mainnet (empty chain)
 	}
 
+	coin_cfg_opts = (
+		'ignore_daemon_version',
+		'rpc_host',
+		'rpc_port',
+		'max_tx_fee',
+	)
+
+	proto_cfg_opts = (
+		'chain_names',
+	)
+
 	@property
 	def dcoin(self):
 		return self.tokensym or self.coin

mmgen/proto/eth/rpc.py

@@ -48,7 +48,7 @@ class EthereumRPCClient(RPCClient, metaclass=AsyncInit):
 
 		super().__init__(
 			cfg  = cfg,
-			host = 'localhost' if cfg.test_suite else (cfg.rpc_host or 'localhost'),
+			host = 'localhost' if cfg.test_suite else (proto.rpc_host or cfg.rpc_host or 'localhost'),
 			port = daemon.rpc_port)
 
 		await self.set_backend_async(backend)

mmgen/proto/ltc/params.py

@@ -20,13 +20,12 @@ class mainnet(mainnet):
 	wif_ver_num     = {'std': 'b0'}
 	mmtypes         = ('L', 'C', 'S', 'B')
 	coin_amt        = 'LTCAmt'
-	max_tx_fee      = '0.3'
+	max_tx_fee      = 0.3
 	base_coin       = 'LTC'
 	forks           = []
 	bech32_hrp      = 'ltc'
 	avg_bdi         = 150
 	halving_interval = 840000
-	ignore_daemon_version = False
 
 class testnet(mainnet):
 	# addr ver nums same as Bitcoin testnet, except for 'p2sh'

mmgen/proto/xmr/params.py

@@ -23,7 +23,7 @@ class MoneroViewKey(HexStr):
 	color, width, hexcase = 'cyan', 64, 'lower' # FIXME - no checking performed
 
 # https://github.com/monero-project/monero/blob/master/src/cryptonote_config.h
-class mainnet(CoinProtocol.DummyWIF, CoinProtocol.Base):
+class mainnet(CoinProtocol.RPC, CoinProtocol.DummyWIF, CoinProtocol.Base):
 
 	network_names  = _nw('mainnet', 'stagenet', None)
 	base_proto     = 'Monero'
@@ -37,10 +37,14 @@ class mainnet(CoinProtocol.DummyWIF, CoinProtocol.Base):
 	avg_bdi        = 120
 	privkey_len    = 32
 	mmcaps         = ('rpc',)
-	ignore_daemon_version = False
 	coin_amt       = 'XMRAmt'
 	sign_mode      = 'standalone'
 
+	coin_cfg_opts = (
+		'ignore_daemon_version',
+		'rpc_port',
+	)
+
 	def get_addr_len(self, addr_fmt):
 		return (64, 72)[addr_fmt == 'monero_integrated']
 

mmgen/protocol.py

@@ -110,12 +110,17 @@ class CoinProtocol(MMGenObject):
 				from . import amt
 				from decimal import getcontext
 				self.coin_amt = getattr(amt, self.coin_amt)
-				self.max_tx_fee = self.coin_amt(self.max_tx_fee) if hasattr(self, 'max_tx_fee') else None
+				self.max_tx_fee = self.coin_amt(str(self.max_tx_fee)) if hasattr(self, 'max_tx_fee') else None
 				getcontext().prec = self.decimal_prec
 			else:
 				self.coin_amt = None
 				self.max_tx_fee = None
 
+			self.set_cfg_opts()
+
+		def set_cfg_opts(self):
+			pass
+
 		@property
 		def dcoin(self):
 			return self.coin
@@ -192,8 +197,43 @@ class CoinProtocol(MMGenObject):
 			else:
 				return getattr(importlib.import_module(modpath), clsname)
 
+	class RPC:
+
+		# prefixed with coin, e.g. ‘ltc_rpc_host’: refvals taken from proto class
+		coin_cfg_opts = ()
+
+		# prefixed with coin + network, e.g. ‘eth_mainnet_chain_names’: refvals taken from proto class
+		proto_cfg_opts = ()
+
+		# default vals (refvals): bool(val) must be False (val = None -> option takes no parameter)
+		ignore_daemon_version = None
+		rpc_host              = ''
+		rpc_port              = 0
+		rpc_user              = ''
+		rpc_password          = ''
+		tw_name               = ''
+
+		@classmethod
+		def get_opt_clsval(cls, cfg, opt):
+			coin, *rem = opt.split('_', 2)
+			network = rem[0] if rem[0] in init_proto(cfg, coin, return_cls=True).network_names else None
+			opt_name = '_'.join(rem[bool(network):])
+			if ((network is None and opt_name in cls.coin_cfg_opts) or
+				(network and opt_name in cls.proto_cfg_opts)):
+				# raises AttributeError on failure:
+				return getattr(init_proto(cfg, coin, network=network, return_cls=True), opt_name)
+			else:
+				raise AttributeError(f'{opt_name}: unrecognized attribute')
+
+		def set_cfg_opts(self):
+			for opt in self.cfg.__dict__:
+				if opt.startswith(self.coin.lower() + '_'):
+					res = opt.split('_', 2)[1:]
+					network = res[0] if res[0] in self.network_names else None
+					if network is None or network == self.network:
+						setattr(self, '_'.join(res[bool(network):]), getattr(self.cfg, opt))
 
-	class Secp256k1(Base):
+	class Secp256k1(RPC, Base):
 		"""
 		Bitcoin and Ethereum protocols inherit from this class
 		"""

setup.py

@@ -10,7 +10,7 @@
 
 import sys, os
 from pathlib import Path
-from subprocess import run, PIPE
+from subprocess import run
 from setuptools import setup, Extension
 from setuptools.command.build_ext import build_ext
 

test/cmdtest_d/ct_cfgfile.py

@@ -203,10 +203,10 @@ class CmdTestCfgFile(CmdTestBase):
 
 		for coin, res1_chk, res2_chk, res2_chk_eq in (
 			('BTC', 'True',  '1.2345', True),
-			('LTC', 'False', '1.2345', False),
-			('BCH', 'False', '1.2345', False),
+			('LTC', 'None',  '1.2345', False),
+			('BCH', 'None',  '1.2345', False),
 			('ETH', 'True',  '5.4321', True),
-			('ETC', 'False', '5.4321', False)
+			('ETC', 'None',  '5.4321', False)
 		):
 			if cfg.no_altcoin and coin != 'BTC':
 				continue

test/cmdtest_d/ct_opts.py

@@ -46,6 +46,13 @@ class CmdTestOpts(CmdTestBase):
 		('opt_good22',           (41, 'good cmdline opt (opt + negated opt [substring])', [])),
 		('opt_good23',           (41, 'good cmdline opt (negated negative opt [substring])', [])),
 		('opt_good24',           (41, 'good cmdline opt (negated opt + opt [substring])', [])),
+		('opt_good25',           (41, 'good cmdline opt (--btc-rpc-host)', [])),
+		('opt_good26',           (41, 'good cmdline opt (--btc-rpc-port)', [])),
+		('opt_good27',           (41, 'good cmdline opt (--btc-ignore-daemon-version)', [])),
+		('opt_good28',           (41, 'good cmdline opt (--bch-cashaddr)', [])),
+		('opt_good29',           (41, 'good cmdline opt (--etc-max-tx-fee=0.1)', [])),
+		('opt_good30',           (41, 'good cmdline opt (--eth-chain-names=foo,bar)', [])),
+		('opt_good31',           (41, 'good cmdline opt (--xmr-rpc-port=28081)', [])),
 		('opt_bad_param',        (41, 'bad global opt (--pager=1)', [])),
 		('opt_bad_infile',       (41, 'bad infile parameter', [])),
 		('opt_bad_outdir',       (41, 'bad outdir parameter', [])),
@@ -65,15 +72,42 @@ class CmdTestOpts(CmdTestBase):
 		('opt_invalid_14',       (41, 'invalid cmdline opt (long opt substring too short)', [])),
 		('opt_invalid_15',       (41, 'invalid cmdline (too many args)', [])),
 		('opt_invalid_16',       (41, 'invalid cmdline (overlong arg)', [])),
+		('opt_invalid_17',       (41, 'invalid cmdline opt (--btc-rpc-host without ‘need_proto’)', [])),
+		('opt_invalid_18',       (41, 'invalid cmdline opt (--btc-rpc-port without ‘need_proto’)', [])),
+		('opt_invalid_19',       (41, 'invalid cmdline opt (--btc-rpc-port with non-integer param)', [])),
+		('opt_invalid_21',       (41, 'invalid cmdline opt (--btc-foo)', [])),
+		('opt_invalid_22',       (41, 'invalid cmdline opt (--btc-rpc-host with missing param)', [])),
+		('opt_invalid_23',       (41, 'invalid cmdline opt (--btc-ignore-daemon-version with param)', [])),
+		('opt_invalid_24',       (41, 'invalid cmdline opt (--bch-cashaddr without ‘need_proto’)', [])),
+		('opt_invalid_25',       (41, 'invalid cmdline opt (--bch-cashaddr without parameter)', [])),
+		('opt_invalid_26',       (41, 'invalid cmdline opt (--bch-cashaddr with non-bool parameter)', [])),
+		('opt_invalid_27',       (41, 'invalid cmdline opt (--ltc-cashaddr)', [])),
+		('opt_invalid_28',       (41, 'invalid cmdline opt (--xmr-max-tx-fee)', [])),
+		('opt_invalid_29',       (41, 'invalid cmdline opt (--eth-max-tx-fee without parameter)', [])),
+		('opt_invalid_30',       (41, 'invalid cmdline opt (--eth-max-tx-fee with non-numeric parameter)', [])),
+		('opt_invalid_31',       (41, 'invalid cmdline opt (--bch-cashaddr without --coin=bch)', [])),
+		('opt_invalid_32',       (41, 'invalid cmdline opt (--eth-chain-names without --coin=eth)', [])),
+		('opt_invalid_33',       (41, 'invalid cmdline opt (--xmr-rpc-host)', [])),
+		('opt_invalid_34',       (41, 'invalid cmdline opt (--eth-rpc-user)', [])),
 	)
 
-	def spawn_prog(self, args, exit_val=None):
-		return self.spawn('test/misc/opts.py', args, cmd_dir='.', exit_val=exit_val)
-
-	def check_vals(self, args, vals):
-		t = self.spawn_prog(args)
-		for k, v in vals:
-			t.expect(rf'{k}:\s+{v}', regex=True)
+	def spawn_prog(self, args, opts=[], exit_val=None, need_proto=False):
+		return self.spawn(
+			'test/misc/opts.py',
+			opts + args,
+			cmd_dir  = '.',
+			exit_val = exit_val,
+			env      = {'TEST_MISC_OPTS_NEEDS_PROTO': '1' if need_proto else ''})
+
+	def check_vals(self, args, vals, check=True, need_proto=False):
+		show_opts = [a.removeprefix('cfg.') for a, b in vals if a.startswith('cfg.')]
+		t = self.spawn_prog(
+			args,
+			opts       = ['--show-opts=' + ','.join(show_opts)] if show_opts else [],
+			need_proto = need_proto)
+		if check:
+			for k, v in vals:
+				t.expect(rf'{k}:\s+{v}', regex=True)
 		return t
 
 	def do_run(self, args, expect, exit_val, regex=False):
@@ -232,6 +266,45 @@ class CmdTestOpts(CmdTestBase):
 	def opt_good24(self):
 		return self.check_vals(['--no-pag', '--pag'], (('cfg.pager', 'True'),))
 
+	def opt_good25(self):
+		return self.check_vals(
+			['--btc-rpc-host=pi5'],
+			(('cfg.btc_rpc_host', 'pi5'), ('proto.rpc_host', 'pi5')),
+			need_proto=True)
+
+	def opt_good26(self):
+		return self.check_vals(
+			['--btc-rpc-port=7272'],
+			(('cfg.btc_rpc_port', '7272'), ('proto.rpc_port', '7272')),
+			need_proto=True)
+
+	def opt_good27(self):
+		return self.check_vals(
+			['--btc-ignore-daemon-version'],
+			(('cfg.btc_ignore_daemon_version', 'True'), ('proto.ignore_daemon_version', 'True'),),
+			need_proto = True)
+
+	def opt_good28(self):
+		return self.check_vals(
+			['--coin=bch', '--bch-cashaddr=yes'],
+			(('cfg.bch_cashaddr', 'True'), ('proto.cashaddr', 'True'),),
+			need_proto = True)
+
+	def opt_good29(self):
+		return self.check_vals(['--etc-max-tx-fee=0.1'], (('cfg.etc_max_tx_fee', '0.1'),), need_proto=True)
+
+	def opt_good30(self):
+		return self.check_vals(
+			['--coin=eth', '--eth-mainnet-chain-names=foo,bar'],
+			(('cfg.eth_mainnet_chain_names', r"\['foo', 'bar'\]"), ('proto.chain_names', r"\['foo', 'bar'\]")),
+			need_proto = True)
+
+	def opt_good31(self):
+		return self.check_vals(
+			['--coin=xmr', '--xmr-rpc-port=28081'],
+			(('cfg.xmr_rpc_port', '28081'),('proto.rpc_port', '28081'),),
+			need_proto = True)
+
 	def opt_bad_param(self):
 		return self.do_run(['--pager=1'], 'no parameter', 1)
 
@@ -249,49 +322,100 @@ class CmdTestOpts(CmdTestBase):
 	def opt_bad_autoset(self):
 		return self.do_run(['--fee-estimate-mode=Fubar'], 'not unique substring', 1)
 
-	def opt_invalid(self, args, expect, exit_val):
-		t = self.spawn_prog(args, exit_val=exit_val)
+	def opt_invalid(self, args, expect, opts=[], need_proto=False, exit_val=1):
+		t = self.spawn_prog(args, opts=opts, exit_val=exit_val, need_proto=need_proto)
 		t.expect(expect)
 		return t
 
 	def opt_invalid_1(self):
-		return self.opt_invalid(['--x'], 'must be at least', 1)
+		return self.opt_invalid(['--x'], 'must be at least')
 
 	def opt_invalid_2(self):
-		return self.opt_invalid(['---'], 'must be at least', 1)
+		return self.opt_invalid(['---'], 'must be at least')
 
 	def opt_invalid_5(self):
-		return self.opt_invalid(['-l'], 'missing parameter', 1)
+		return self.opt_invalid(['-l'], 'missing parameter')
 
 	def opt_invalid_6(self):
-		return self.opt_invalid(['-l', '-k'], 'missing parameter', 1)
+		return self.opt_invalid(['-l', '-k'], 'missing parameter')
 
 	def opt_invalid_7(self):
-		return self.opt_invalid(['--quiet=1'], 'requires no parameter', 1)
+		return self.opt_invalid(['--quiet=1'], 'requires no parameter')
 
 	def opt_invalid_8(self):
-		return self.opt_invalid(['-w'], 'unrecognized option', 1)
+		return self.opt_invalid(['-w'], 'unrecognized option')
 
 	def opt_invalid_9(self):
-		return self.opt_invalid(['--frobnicate'], 'unrecognized option', 1)
+		return self.opt_invalid(['--frobnicate'], 'unrecognized option')
 
 	def opt_invalid_10(self):
-		return self.opt_invalid(['--label', '-q'], 'missing parameter', 1)
+		return self.opt_invalid(['--label', '-q'], 'missing parameter')
 
 	def opt_invalid_11(self):
-		return self.opt_invalid(['-T', '-10'], 'missing parameter', 1)
+		return self.opt_invalid(['-T', '-10'], 'missing parameter')
 
 	def opt_invalid_12(self):
-		return self.opt_invalid(['-q', '-10'], 'unrecognized option', 1)
+		return self.opt_invalid(['-q', '-10'], 'unrecognized option')
 
 	def opt_invalid_13(self):
-		return self.opt_invalid(['--mi=3'], 'ambiguous option', 1)
+		return self.opt_invalid(['--mi=3'], 'ambiguous option')
 
 	def opt_invalid_14(self):
-		return self.opt_invalid(['--m=3'], 'must be at least', 1)
+		return self.opt_invalid(['--m=3'], 'must be at least')
 
 	def opt_invalid_15(self):
-		return self.opt_invalid(['m'] * 257, 'too many', 1)
+		return self.opt_invalid(['m'] * 257, 'too many')
 
 	def opt_invalid_16(self):
-		return self.opt_invalid(['e' * 4097], 'too long', 1)
+		return self.opt_invalid(['e' * 4097], 'too long')
+
+	def opt_invalid_17(self):
+		return self.opt_invalid(['--btc-rpc-host'], 'unrecognized option')
+
+	def opt_invalid_18(self):
+		return self.opt_invalid(['--btc-rpc-port'], 'unrecognized option')
+
+	def opt_invalid_19(self):
+		return self.opt_invalid(['--btc-rpc-port=foo'], "must be of type 'int'", need_proto=True)
+
+	def opt_invalid_21(self):
+		return self.opt_invalid(['--btc-foo'], 'unrecognized option')
+
+	def opt_invalid_22(self):
+		return self.opt_invalid(['--btc-rpc-host'], 'missing parameter', need_proto=True)
+
+	def opt_invalid_23(self):
+		return self.opt_invalid(['--btc-ignore-daemon-version=1'], 'requires no parameter', need_proto=True)
+
+	def opt_invalid_24(self):
+		return self.opt_invalid(['--bch-cashaddr'], 'unrecognized option')
+
+	def opt_invalid_25(self):
+		return self.opt_invalid(['--bch-cashaddr'], 'missing parameter', need_proto=True)
+
+	def opt_invalid_26(self):
+		return self.opt_invalid(['--bch-cashaddr=foo'], "must be of type 'bool'", need_proto=True)
+
+	def opt_invalid_27(self):
+		return self.opt_invalid(['--ltc-cashaddr'], 'unrecognized option', need_proto=True)
+
+	def opt_invalid_28(self):
+		return self.opt_invalid(['--xmr-max-tx-fee=0.1'], 'unrecognized option', need_proto=True)
+
+	def opt_invalid_29(self):
+		return self.opt_invalid(['--eth-max-tx-fee'], 'missing parameter', need_proto=True)
+
+	def opt_invalid_30(self):
+		return self.opt_invalid(['--eth-max-tx-fee=true'], 'must be of type', need_proto=True)
+
+	def opt_invalid_31(self):
+		return self.opt_invalid(['--bch-cashaddr=true'], 'has no attribute', opts=['--show-opts=bch_cashaddr'], need_proto=True)
+
+	def opt_invalid_32(self):
+		return self.opt_invalid(['--eth-chain-names=foo,bar'], 'unrecognized option', need_proto=True)
+
+	def opt_invalid_33(self):
+		return self.opt_invalid(['--xmr-rpc-host=solaris'], 'unrecognized option', need_proto=True)
+
+	def opt_invalid_34(self):
+		return self.opt_invalid(['--eth-rpc-user=bob'], 'unrecognized option', need_proto=True)

test/daemontest_d/ut_rpc.py

@@ -66,6 +66,8 @@ async def print_daemon_info(rpc):
     CUR_DATE:       {rpc.cur_date} [{make_timestr(rpc.cur_date)}]
 		""".rstrip())
 
+	msg(f'    BIND_PORT:      {rpc.daemon.bind_port}')
+
 	if rpc.proto.base_proto == 'Bitcoin':
 		def fmt_dict(d):
 			return '\n        ' + '\n        '.join(pp_fmt(d).split('\n')) + '\n'
@@ -76,6 +78,9 @@ async def print_daemon_info(rpc):
     WALLETINFO:     {fmt_dict(await rpc.walletinfo)}
 		""".rstrip())
 
+	if rpc.proto.base_proto == 'Ethereum':
+		msg(f'    CHAIN_NAMES:    {" ".join(rpc.daemon.proto.chain_names)}')
+
 	msg('')
 
 def do_msg(rpc, backend):
@@ -85,13 +90,14 @@ def do_msg(rpc, backend):
 class init_test:
 
 	@staticmethod
-	async def btc(cfg, daemon, backend):
+	async def btc(cfg, daemon, backend, cfg_override):
 		rpc = await rpc_init(cfg, daemon.proto, backend, daemon)
 		do_msg(rpc, backend)
 
-		if cfg.tw_name:
-			wi = await rpc.walletinfo
-			assert wi['walletname'] == rpc.cfg.tw_name, f'{wi["walletname"]!r} != {rpc.cfg.tw_name!r}'
+		wi = await rpc.walletinfo
+		assert wi['walletname'] == cfg_override['btc_tw_name']
+		assert wi['walletname'] == rpc.cfg._proto.tw_name, f'{wi["walletname"]!r} != {rpc.cfg._proto.tw_name!r}'
+		assert daemon.bind_port == cfg_override['btc_rpc_port']
 
 		bh = (await rpc.call('getblockchaininfo', timeout=300))['bestblockhash']
 		await rpc.gathered_call('getblock', ((bh,), (bh, 1)), timeout=300)
@@ -99,7 +105,7 @@ class init_test:
 		return rpc
 
 	@staticmethod
-	async def bch(cfg, daemon, backend):
+	async def bch(cfg, daemon, backend, cfg_override):
 		rpc = await rpc_init(cfg, daemon.proto, backend, daemon)
 		do_msg(rpc, backend)
 		return rpc
@@ -107,15 +113,18 @@ class init_test:
 	ltc = bch
 
 	@staticmethod
-	async def eth(cfg, daemon, backend):
+	async def eth(cfg, daemon, backend, cfg_override):
 		rpc = await rpc_init(cfg, daemon.proto, backend, daemon)
 		do_msg(rpc, backend)
 		await rpc.call('eth_blockNumber', timeout=300)
+		if rpc.proto.network == 'testnet':
+			assert daemon.proto.chain_names == cfg_override['eth_testnet_chain_names']
+			assert daemon.bind_port == cfg_override['eth_rpc_port']
 		return rpc
 
 	etc = eth
 
-async def run_test(network_ids, test_cf_auth=False, daemon_ids=None, cfg_in=None):
+async def run_test(network_ids, test_cf_auth=False, daemon_ids=None, cfg_override=None):
 
 	async def do_test(d, cfg):
 
@@ -131,7 +140,7 @@ async def run_test(network_ids, test_cf_auth=False, daemon_ids=None, cfg_in=None
 
 		for n, backend in enumerate(cfg._autoset_opts['rpc_backend'].choices):
 			test = getattr(init_test, d.proto.coin.lower())
-			rpc = await test(cfg, d, backend)
+			rpc = await test(cfg, d, backend, cfg_override)
 			if not n and cfg.verbose:
 				await print_daemon_info(rpc)
 
@@ -145,14 +154,14 @@ async def run_test(network_ids, test_cf_auth=False, daemon_ids=None, cfg_in=None
 
 		qmsg('')
 
-	cfg_arg = cfg_in or cfg
+	my_cfg = Config(cfg_override) if cfg_override else cfg
 
 	for network_id in network_ids:
-		proto = init_proto(cfg_arg, network_id=network_id)
-		all_ids = CoinDaemon.get_daemon_ids(cfg_arg, proto.coin)
+		proto = init_proto(my_cfg, network_id=network_id)
+		all_ids = CoinDaemon.get_daemon_ids(my_cfg, proto.coin)
 		ids = set(daemon_ids) & set(all_ids) if daemon_ids else all_ids
 		for daemon_id in ids:
-			await do_test(CoinDaemon(cfg_arg, proto=proto, test_suite=True, daemon_id=daemon_id), cfg_arg)
+			await do_test(CoinDaemon(my_cfg, proto=proto, test_suite=True, daemon_id=daemon_id), my_cfg)
 
 	return True
 
@@ -165,7 +174,15 @@ class unit_tests:
 		return await run_test(
 			['btc', 'btc_tn'],
 			test_cf_auth = True,
-			cfg_in = Config({'_clone': cfg, 'tw_name': 'alternate-tracking-wallet'}))
+			cfg_override = {
+				'_clone': cfg,
+				'btc_rpc_port': 19777,
+				'rpc_port':     32323, # ignored
+				'btc_tw_name': 'alternate-tracking-wallet',
+				'tw_name':     'this-is-overridden',
+				'ltc_tw_name': 'this-is-ignored',
+				'eth_mainnet_chain_names': ['also', 'ignored'],
+		})
 
 	async def ltc(self, name, ut):
 		return await run_test(['ltc', 'ltc_tn'], test_cf_auth=True)
@@ -175,7 +192,17 @@ class unit_tests:
 
 	async def geth(self, name, ut):
 		# mainnet returns EIP-155 error on empty blockchain:
-		return await run_test(['eth_tn', 'eth_rt'], daemon_ids=['geth'])
+		return await run_test(
+			['eth_tn', 'eth_rt'],
+			daemon_ids = ['geth'],
+			cfg_override = {
+				'_clone': cfg,
+				'eth_rpc_port': 19777,
+				'rpc_port':     32323, # ignored
+				'btc_tw_name': 'ignored',
+				'tw_name':     'also-ignored',
+				'eth_testnet_chain_names': ['goerli', 'foo', 'bar', 'baz'],
+		})
 
 	async def erigon(self, name, ut):
 		return await run_test(['eth', 'eth_tn', 'eth_rt'], daemon_ids=['erigon'])

test/misc/cfg_main.py

@@ -31,7 +31,8 @@ if op:
 		msg('usr cfg: {}'.format(' '.join(f'{i.name}={i.value}' for i in pu)))
 	elif op == 'coin_specific_vars':
 		for varname in args:
-			msg('{}.{}: {}'.format(
+			msg('{}.{}.{}: {}'.format(
+				cfg._proto.coin.lower(),
 				type(cfg._proto).__name__,
 				varname,
 				getattr(cfg._proto, varname)

test/misc/opts_main.py

@@ -1,5 +1,7 @@
 #!/usr/bin/env python3
 
+import os
+
 from mmgen.cfg import Config
 from mmgen.util import msg
 
@@ -23,6 +25,7 @@ opts_data = {
 -L, --label=       l  Specify a label 'l' for output wallet
 -m, --minconf=     n  Minimum number of confirmations required to spend
                       outputs (default: 1)
+-o, --show-opts=   L  List of cfg opts to display
 -p, --hash-preset= p  Use the scrypt hash parameters defined by preset 'p'
 -P, --passwd-file= f  Get wallet passphrase from file 'f'
 -q, --quiet           Be quieter
@@ -43,46 +46,26 @@ sample note: {nn}
 	},
 	'code': {
 		'options': lambda cfg, help_notes, s: s.format(
-			kgs=help_notes('keygen_backends'),
-			coin_id=help_notes('coin_id'),
+			kgs     = help_notes('keygen_backends'),
+			coin_id = help_notes('coin_id'),
 		),
 		'notes': lambda s: s.format(nn='a note'),
 	}
 }
 
-cfg = Config(opts_data=opts_data)
-
-for k in (
-		'foo',               # added opt
-		'print_checksum',    # sets 'quiet'
-		'quiet', 'verbose',  # _incompatible_opts
-		'passwd_file',       # _infile_opts - check_infile()
-		'outdir',            # check_outdir()
-		'cached_balances',   # opt_sets_global
-		'minconf',           # global_sets_opt
-		'hidden_incog_input_params',
-		'keep_label',
-		'seed_len',
-		'hash_preset',
-		'label',
-		'min_temp',
-		'max_temp',
-		'coin',
-		'pager',
-		'point',
-		'no_foobleize'):
-	msg('{:30} {}'.format(f'cfg.{k}:', getattr(cfg, k)))
+cfg = Config(opts_data=opts_data, need_proto=os.getenv('TEST_MISC_OPTS_NEEDS_PROTO'))
 
-msg('')
-for k in (
-		'cached_balances',   # opt_sets_global
-		'minconf'):          # global_sets_opt
-	msg('{:30} {}'.format(f'cfg.{k}:', getattr(cfg, k)))
-
-msg('')
-for k in ('fee_estimate_mode',): # _autoset_opts
-	msg('{:30} {}'.format(f'cfg.{k}:', getattr(cfg, k)))
+if cfg.show_opts:
+	opts = cfg.show_opts.split(',')
+	col1_w = max(len(s) for s in opts) + 5
+	for opt in opts:
+		msg('{:{w}} {}'.format(f'cfg.{opt}:', getattr(cfg, opt), w=col1_w))
+		if cfg._proto:
+			coin, *rem = opt.split('_')
+			network = rem[0] if rem[0] in cfg._proto.network_names else None
+			opt_name = '_'.join(rem[bool(network):])
+			msg('{:{w}} {}'.format(f'proto.{opt_name}:', getattr(cfg._proto, opt_name), w=col1_w))
 
 msg('')
-for n, k in enumerate(cfg._args, 1):
-	msg(f'arg{n}: {k}')
+for n, arg in enumerate(cfg._args, 1):
+	msg(f'arg{n}: {arg}')

test/test-release.d/cfg.sh

@@ -74,6 +74,7 @@ init_tests() {
 	[ "$VERBOSE" ] || STDOUT_DEVNULL='> /dev/null'
 	d_lint="code errors with static code analyzer"
 	t_lint="
+		b ruff check setup.py $STDOUT_DEVNULL
 		b ruff check mmgen $STDOUT_DEVNULL
 		b ruff check test $STDOUT_DEVNULL
 		b ruff check examples $STDOUT_DEVNULL