test.py: cleanups and fixes throughout

test/test.py

@@ -525,6 +525,12 @@ class CmdGroupMgr(object):
 		cls = self.create_group(gname,**kwargs)
 		return cls(trunner,cfgs,spawn_prog)
 
+	def list_cmd_groups(self):
+		for gname in self.cmd_groups:
+			clsname,kwargs = self.cmd_groups[gname]
+			cls = self.load_mod(gname,kwargs['modname'] if 'modname' in kwargs else None)
+			msg('{:17} - {}'.format(gname,cls.__doc__))
+
 	def find_cmd_in_groups(self,cmd,group=None):
 		"""
 		Search for a test command in specified group or all configured command groups
@@ -875,7 +881,8 @@ if not opt.skip_deps: # do this before list cmds exit, so we stay in sync with s
 	create_tmp_dirs(shm_dir)
 
 if opt.list_cmd_groups:
-	Die(0,' '.join(CmdGroupMgr.cmd_groups))
+	CmdGroupMgr().list_cmd_groups()
+	Die(0,'\n'+' '.join(CmdGroupMgr.cmd_groups))
 elif opt.list_cmds:
 	list_cmds()
 

test/test_py_d/ts_autosign.py

@@ -226,7 +226,7 @@ class TestSuiteAutosignMinimal(TestSuiteAutosign):
 	)
 
 class TestSuiteAutosignLive(TestSuiteAutosignMinimal):
-	'live autosigning operations'
+	'live autosigning operations with device insertion/removal and LED check'
 	cmd_group = (
 		('autosign_live', 'transaction autosigning (BTC,ETH,ETC - test device insertion/removal + LED)'),
 	)

test/test_py_d/ts_ethdev.py

@@ -722,12 +722,13 @@ class TestSuiteEthdev(TestSuiteBase,TestSuiteShared):
 
 	def token_txcreate(self,args=[],token='',inputs='1',fee='50G'):
 		t = self.spawn('mmgen-txcreate', self.eth_args + ['--token='+token,'-B','--tx-fee='+fee] + args)
-		t = self.txcreate_ui_common( t,
-										menu              = [],
-										inputs            = inputs,
-										input_sels_prompt = 'to spend from',
-										file_desc         = 'Ethereum token transaction',
-										add_comment       = tx_label_lat_cyr_gr)
+		t = self.txcreate_ui_common(
+			t,
+			menu              = [],
+			inputs            = inputs,
+			input_sels_prompt = 'to spend from',
+			file_desc         = 'Ethereum token transaction',
+			add_comment       = tx_label_lat_cyr_gr )
 		t.read()
 		return t
 	def token_txsign(self,ext='',token=''):

test/test_py_d/ts_main.py

@@ -22,6 +22,7 @@ ts_main.py: Basic operations tests for the test.py test suite
 
 from mmgen.globalvars import g
 from mmgen.opts import opt
+from mmgen.seed import SeedSource,Wallet,MMGenMnemonic,IncogWallet,MMGenSeedFile
 from test.common import *
 from test.test_py_d.common import *
 from test.test_py_d.ts_base import *
@@ -165,23 +166,23 @@ class TestSuiteMain(TestSuiteBase,TestSuiteShared):
 	def subwalletgen_dfl_wallet(self,pf):
 		return self.subwalletgen(wf='default')
 
-	def export_seed_dfl_wallet(self,pf,desc='seed data',out_fmt='seed'):
-		return self.export_seed(wf=None,desc=desc,out_fmt=out_fmt,pf=pf)
+	def export_seed_dfl_wallet(self,pf,out_fmt='seed'):
+		return self.export_seed(wf=None,out_fmt=out_fmt,pf=pf)
 
 	def addrgen_dfl_wallet(self,pf=None,check_ref=False):
-		return self.addrgen(wf=None,pf=pf,check_ref=check_ref)
+		return self.addrgen(wf=None,pf=pf,check_ref=check_ref,dfl_wallet=True)
 
 	def txcreate_dfl_wallet(self,addrfile):
 		return self.txcreate_common(sources=['15'])
 
 	def txsign_dfl_wallet(self,txfile,pf='',save=True,has_label=False):
-		return self.txsign(txfile,wf=None,pf=pf,save=save,has_label=has_label)
+		return self.txsign(None,txfile,pf=pf,save=save,has_label=has_label,dfl_wallet=True)
 
 	def passchg_dfl_wallet(self,pf):
-		return self.passchg(wf=None,pf=pf)
+		return self.passchg(wf=None,pf=pf,dfl_wallet=True)
 
 	def walletchk_newpass_dfl_wallet(self,pf):
-		return self.walletchk_newpass(wf=None,pf=pf)
+		return self.walletchk_newpass(wf=None,wcls=Wallet,pf=pf,dfl_wallet=True)
 
 	def delete_dfl_wallet(self,pf):
 		self.write_to_tmpfile('del_dw_run',b'',binary=True)
@@ -201,12 +202,13 @@ class TestSuiteMain(TestSuiteBase,TestSuiteShared):
 		t.license()
 		t.usr_rand(self.usr_rand_chars)
 		t.expect('Generating')
-		t.passphrase_new('new MMGen wallet',self.wpasswd)
+		wcls = Wallet
+		t.passphrase_new('new '+wcls.desc,self.wpasswd)
 		t.label()
 		if not self.have_dfl_wallet and gen_dfl_wallet:
 			t.expect('move it to the data directory? (Y/n): ','y')
 			self.have_dfl_wallet = True
-		t.written_to_file('MMGen wallet')
+		t.written_to_file(capfirst(wcls.desc))
 		return t
 
 	def subwalletgen(self,wf):
@@ -214,25 +216,30 @@ class TestSuiteMain(TestSuiteBase,TestSuiteShared):
 		if wf != 'default': args += [wf]
 		t = self.spawn('mmgen-subwalletgen', args + ['10s'])
 		t.license()
-		t.passphrase('MMGen wallet',self.cfgs['1']['wpasswd'])
+		wcls = Wallet
+		t.passphrase(wcls.desc,self.cfgs['1']['wpasswd'])
 		t.expect('Generating subseed 10S')
-		t.passphrase_new('new MMGen wallet','foo')
+		t.passphrase_new('new '+wcls.desc,'foo')
 		t.usr_rand(self.usr_rand_chars)
-		fn = t.written_to_file('MMGen wallet')
-		assert fn[-6:] == '.mmdat','incorrect file extension: {}'.format(fn[-6:])
+		fn = t.written_to_file(capfirst(wcls.desc))
+		ext = get_extension(fn)
+		assert ext,'incorrect file extension: {}'.format(ext)
 		return t
 
 	def subwalletgen_mnemonic(self,wf):
-		args = [self.usr_rand_arg,'-p1','-d',self.tr.trash_dir,'-o','words',wf,'3L']
+		icls = SeedSource.ext_to_type(get_extension(wf))
+		ocls = MMGenMnemonic
+		args = [self.usr_rand_arg,'-p1','-d',self.tr.trash_dir,'-o',ocls.fmt_codes[0],wf,'3L']
 		t = self.spawn('mmgen-subwalletgen', args)
 		t.license()
-		t.passphrase('MMGen wallet',self.cfgs['1']['wpasswd'])
+		t.passphrase(icls.desc,self.cfgs['1']['wpasswd'])
 		t.expect('Generating subseed 3L')
-		fn = t.written_to_file('MMGen native mnemonic data')
-		assert fn[-8:] == '.mmwords','incorrect file extension: {}'.format(fn[-8:])
+		fn = t.written_to_file(capfirst(ocls.desc))
+		ext = get_extension(fn)
+		assert ext == ocls.ext,'incorrect file extension: {}'.format(ext)
 		return t
 
-	def passchg(self,wf,pf,label_action='cmdline'):
+	def passchg(self,wf,pf,label_action='cmdline',dfl_wallet=False):
 		silence()
 		self.write_to_tmpfile(pwfile,get_data_from_file(pf))
 		end_silence()
@@ -240,18 +247,19 @@ class TestSuiteMain(TestSuiteBase,TestSuiteShared):
 					'keep':    ['-d',self.tr.trash_dir,'--keep-label'],
 					'user':    ['-d',self.tr.trash_dir]
 					}[label_action]
-		t = self.spawn('mmgen-passchg', add_args + [self.usr_rand_arg, '-p2'] + ([],[wf])[bool(wf)])
+		t = self.spawn('mmgen-passchg', add_args + [self.usr_rand_arg, '-p2'] + ([wf] if wf else []))
 		t.license()
-		t.passphrase('MMGen wallet',self.cfgs['1']['wpasswd'],pwtype='old')
+		wcls = Wallet
+		t.passphrase(wcls.desc,self.cfgs['1']['wpasswd'],pwtype='old')
 		t.expect_getend('Hash preset changed to ')
-		t.passphrase('MMGen wallet',self.wpasswd,pwtype='new') # reuse passphrase?
+		t.passphrase(wcls.desc,self.wpasswd,pwtype='new') # reuse passphrase?
 		t.expect('Repeat passphrase: ',self.wpasswd+'\n')
 		t.usr_rand(self.usr_rand_chars)
 		if label_action == 'user':
 			t.expect('Enter a wallet label.*: ','Interactive Label (UTF-8) α\n',regex=True)
 		t.expect_getend(('Label changed to ','Reusing label ')[label_action=='keep'])
 #		t.expect_getend('Key ID changed: ')
-		if not wf:
+		if dfl_wallet:
 			t.expect("Type uppercase 'YES' to confirm: ",'YES\n')
 			t.written_to_file('New wallet')
 			t.expect('Securely deleting old wallet')
@@ -259,7 +267,7 @@ class TestSuiteMain(TestSuiteBase,TestSuiteShared):
 			t.expect('Wallet passphrase has changed')
 			t.expect_getend('has been changed to ')
 		else:
-			t.written_to_file('MMGen wallet')
+			t.written_to_file(capfirst(wcls.desc))
 		return t
 
 	def passchg_keeplabel(self,wf,pf):
@@ -268,8 +276,8 @@ class TestSuiteMain(TestSuiteBase,TestSuiteShared):
 	def passchg_usrlabel(self,wf,pf):
 		return self.passchg(wf,pf,label_action='user')
 
-	def walletchk_newpass(self,wf,pf):
-		return self.walletchk(wf,pf,pw=True)
+	def walletchk_newpass(self,wf,pf,wcls=None,dfl_wallet=False):
+		return self.walletchk(wf,pf,wcls=wcls,dfl_wallet=dfl_wallet)
 
 	def _write_fake_data_to_file(self,d):
 		unspent_data_file = joinpath(self.tmpdir,'unspent.json')
@@ -459,8 +467,8 @@ class TestSuiteMain(TestSuiteBase,TestSuiteShared):
 		t.expect('OK? (Y/n): ','\n')
 		if seed_args: # sign and send
 			t.do_comment(False,has_label=True)
-			for cnum,desc in (('1','incognito data'),('3','MMGen wallet'),('4','MMGen wallet')):
-				t.passphrase(desc,self.cfgs[cnum]['wpasswd'])
+			for cnum,wcls in (('1',IncogWallet),('3',Wallet),('4',Wallet)):
+				t.passphrase(wcls.desc,self.cfgs[cnum]['wpasswd'])
 			self._do_confirm_send(t,quiet=not g.debug,confirm_send=True)
 			if g.debug:
 				t.written_to_file('Transaction')
@@ -486,66 +494,73 @@ class TestSuiteMain(TestSuiteBase,TestSuiteShared):
 		self.txsend_ui_common(t)
 		return t
 
-	def _walletconv_export(self,wf,desc,uargs=[],out_fmt='w',pf=None,out_pw=False):
+	def _walletconv_export(self,wf,uargs=[],out_fmt='w',pf=None):
 		opts = ['-d',self.tmpdir,'-o',out_fmt] + uargs + \
 			([],[wf])[bool(wf)] + ([],['-P',pf])[bool(pf)]
 		t = self.spawn('mmgen-walletconv',opts)
 		t.license()
+
 		if not pf:
-			t.passphrase('MMGen wallet',self.wpasswd)
+			icls = SeedSource.ext_to_type(get_extension(wf))
+			t.passphrase(icls.desc,self.wpasswd)
+
+		ocls = SeedSource.fmt_code_to_type(out_fmt)
+		out_pw = issubclass(ocls,SeedSourceEnc) and ocls != Brainwallet
 		if out_pw:
-			t.passphrase_new('new '+desc,self.wpasswd)
+			t.passphrase_new('new '+ocls.desc,self.wpasswd)
 			t.usr_rand(self.usr_rand_chars)
 
-		if ' '.join(desc.split()[-2:]) == 'incognito data':
+		if ocls.__name__.startswith('Incog'):
 			m = 'Generating encryption key from OS random data '
 			t.expect(m); t.expect(m)
 			incog_id = t.expect_getend('New Incog Wallet ID: ')
 			t.expect(m)
-		if desc == 'hidden incognito data':
+		if ocls == IncogWalletHidden:
 			self.write_to_tmpfile(incog_id_fn,incog_id)
 			t.hincog_create(hincog_bytes)
-		if out_fmt == 'w': t.label()
-		return t.written_to_file(capfirst(desc),oo=True),t
+		elif ocls == Wallet:
+			t.label()
+		return t.written_to_file(capfirst(ocls.desc),oo=True),t
 
-	def export_seed(self,wf,desc='seed data',out_fmt='seed',pf=None):
-		f,t = self._walletconv_export(wf,desc=desc,out_fmt=out_fmt,pf=pf)
+	def export_seed(self,wf,out_fmt='seed',pf=None):
+		f,t = self._walletconv_export(wf,out_fmt=out_fmt,pf=pf)
 		silence()
-		msg('{}: {}'.format(capfirst(desc),cyan(get_data_from_file(f,desc))))
+		wcls = SeedSource.fmt_code_to_type(out_fmt)
+		msg('{}: {}'.format(capfirst(wcls.desc),cyan(get_data_from_file(f,wcls.desc))))
 		end_silence()
 		return t
 
-	def export_hex(self,wf,desc='hexadecimal seed data with checksum',out_fmt='mmhex',pf=None):
-		return self.export_seed(wf,desc=desc,out_fmt=out_fmt,pf=pf)
+	def export_hex(self,wf,out_fmt='mmhex',pf=None):
+		return self.export_seed(wf,out_fmt=out_fmt,pf=pf)
 
 	def export_mnemonic(self,wf):
-		return self.export_seed(wf,desc='MMGen native mnemonic data',out_fmt='words')
+		return self.export_seed(wf,out_fmt='words')
 
 	def export_bip39(self,wf):
-		return self.export_seed(wf,desc='BIP39 mnemonic data',out_fmt='bip39')
+		return self.export_seed(wf,out_fmt='bip39')
 
-	def export_incog(self,wf,desc='incognito data',out_fmt='i',add_args=[]):
+	def export_incog(self,wf,out_fmt='i',add_args=[]):
 		uargs = ['-p1',self.usr_rand_arg] + add_args
-		f,t = self._walletconv_export(wf,desc=desc,out_fmt=out_fmt,uargs=uargs,out_pw=True)
+		f,t = self._walletconv_export(wf,out_fmt=out_fmt,uargs=uargs)
 		return t
 
 	def export_incog_hex(self,wf):
-		return self.export_incog(wf,desc='hex incognito data',out_fmt='xi')
+		return self.export_incog(wf,out_fmt='xi')
 
 	# TODO: make outdir and hidden incog compatible (ignore --outdir and warn user?)
 	def export_incog_hidden(self,wf):
 		rf = joinpath(self.tmpdir,hincog_fn)
 		add_args = ['-J','{},{}'.format(rf,hincog_offset)]
-		return self.export_incog(
-			wf,desc='hidden incognito data',out_fmt='hi',add_args=add_args)
+		return self.export_incog(wf,out_fmt='hi',add_args=add_args)
 
-	def addrgen_seed(self,wf,foo,desc='seed data',in_fmt='seed'):
-		stdout = desc == 'seed data' # capture output to screen once
+	def addrgen_seed(self,wf,foo,in_fmt='seed'):
+		wcls = SeedSource.fmt_code_to_type(in_fmt)
+		stdout = wcls == MMGenSeedFile # capture output to screen once
 		add_args = ([],['-S'])[bool(stdout)] + self.segwit_arg
 		t = self.spawn('mmgen-addrgen', add_args +
 				['-i'+in_fmt,'-d',self.tmpdir,wf,self.addr_idx_list])
 		t.license()
-		t.expect_getend('Valid {} for Seed ID '.format(desc))
+		t.expect_getend('Valid {} for Seed ID '.format(wcls.desc))
 		vmsg('Comparing generated checksum with checksum from previous address file')
 		chk = t.expect_getend(r'Checksum for address data .*?: ',regex=True)
 		if stdout: t.read()
@@ -555,19 +570,20 @@ class TestSuiteMain(TestSuiteBase,TestSuiteShared):
 			t.req_exit_val = 1
 		return t
 
-	def addrgen_hex(self,wf,foo,desc='hexadecimal seed data with checksum',in_fmt='mmhex'):
-		return self.addrgen_seed(wf,foo,desc=desc,in_fmt=in_fmt)
+	def addrgen_hex(self,wf,foo,in_fmt='mmhex'):
+		return self.addrgen_seed(wf,foo,in_fmt=in_fmt)
 
 	def addrgen_mnemonic(self,wf,foo):
-		return self.addrgen_seed(wf,foo,desc='MMGen native mnemonic data',in_fmt='words')
+		return self.addrgen_seed(wf,foo,in_fmt='words')
 
-	def addrgen_incog(self,wf=[],foo='',in_fmt='i',desc='incognito data',args=[]):
+	def addrgen_incog(self,wf=[],foo='',in_fmt='i',args=[]):
 		t = self.spawn('mmgen-addrgen', args + self.segwit_arg + ['-i'+in_fmt,'-d',self.tmpdir]+
 				([],[wf])[bool(wf)] + [self.addr_idx_list])
 		t.license()
 		t.expect_getend('Incog Wallet ID: ')
-		t.hash_preset(desc,'1')
-		t.passphrase('{} \w{{8}}'.format(desc),self.wpasswd)
+		wcls = SeedSource.fmt_code_to_type(in_fmt)
+		t.hash_preset(wcls.desc,'1')
+		t.passphrase('{} \w{{8}}'.format(wcls.desc),self.wpasswd)
 		vmsg('Comparing generated checksum with checksum from address file')
 		chk = t.expect_getend(r'Checksum for address data .*?: ',regex=True)
 		verify_checksum_or_exit(self._get_addrfile_checksum(),chk)
@@ -576,11 +592,11 @@ class TestSuiteMain(TestSuiteBase,TestSuiteShared):
 		return t
 
 	def addrgen_incog_hex(self,wf,foo):
-		return self.addrgen_incog(wf,'',in_fmt='xi',desc='hex incognito data')
+		return self.addrgen_incog(wf,'',in_fmt='xi')
 
 	def addrgen_incog_hidden(self,wf,foo):
 		rf = joinpath(self.tmpdir,hincog_fn)
-		return self.addrgen_incog([],'',in_fmt='hi',desc='hidden incognito data',
+		return self.addrgen_incog([],'',in_fmt='hi',
 			args=['-H','{},{}'.format(rf,hincog_offset),'-l',str(hincog_seedlen)])
 
 	def txsign_keyaddr(self,keyaddr_file,txfile):
@@ -603,12 +619,13 @@ class TestSuiteMain(TestSuiteBase,TestSuiteShared):
 	def txcreate2(self,addrfile):
 		return self.txcreate_common(sources=['2'])
 
-	def txsign2(self,txf1,wf1,txf2,wf2):
+	def txsign2(self,wf1,txf1,wf2,txf2):
 		t = self.spawn('mmgen-txsign', ['-d',self.tmpdir,txf1,wf1,txf2,wf2])
 		t.license()
-		for cnum in ('1','2'):
+		for cnum,wf in (('1',wf1),('2',wf2)):
+			wcls = SeedSource.ext_to_type(get_extension(wf))
 			t.view_tx('n')
-			t.passphrase('MMGen wallet',self.cfgs[cnum]['wpasswd'])
+			t.passphrase(wcls.desc,self.cfgs[cnum]['wpasswd'])
 			self.txsign_end(t,cnum)
 		return t
 
@@ -628,8 +645,9 @@ class TestSuiteMain(TestSuiteBase,TestSuiteShared):
 		t = self.spawn('mmgen-txsign', ['-d',self.tmpdir,wf1,wf2,txf2])
 		t.license()
 		t.view_tx('n')
-		for cnum in ('1','3'):
-			t.passphrase('MMGen wallet',self.cfgs[cnum]['wpasswd'])
+		for cnum,wf in (('1',wf1),('3',wf2)):
+			wcls = SeedSource.ext_to_type(get_extension(wf))
+			t.passphrase(wcls.desc,self.cfgs[cnum]['wpasswd'])
 		self.txsign_end(t)
 		return t
 
@@ -644,10 +662,11 @@ class TestSuiteMain(TestSuiteBase,TestSuiteShared):
 		args = ['-d',self.tmpdir,'-p1',self.usr_rand_arg,'-l'+seed_len,'-ib']
 		t = self.spawn('mmgen-walletconv', args + [bwf])
 		t.license()
-		t.passphrase_new('new MMGen wallet',self.wpasswd)
+		wcls = Wallet
+		t.passphrase_new('new ' +wcls.desc,self.wpasswd)
 		t.usr_rand(self.usr_rand_chars)
 		t.label()
-		t.written_to_file('MMGen wallet')
+		t.written_to_file(capfirst(wcls.desc))
 		return t
 
 	def addrgen4(self,wf):
@@ -664,8 +683,8 @@ class TestSuiteMain(TestSuiteBase,TestSuiteShared):
 		t.do_decrypt_ka_data(hp='1',pw=self.cfgs['14']['kapasswd'])
 		t.view_tx('t')
 
-		for cnum,desc in (('1','incognito data'),('3','MMGen wallet')):
-			t.passphrase('{}'.format(desc),self.cfgs[cnum]['wpasswd'])
+		for cnum,wcls in (('1',IncogWallet),('3',Wallet)):
+			t.passphrase('{}'.format(wcls.desc),self.cfgs[cnum]['wpasswd'])
 
 		self.txsign_end(t,has_label=True)
 		return t
@@ -677,8 +696,8 @@ class TestSuiteMain(TestSuiteBase,TestSuiteShared):
 		t = self.txcreate_common(sources=['1','2','3','4','14'],
 					non_mmgen_input='4',do_label=True,txdo_args=[f7,f8,f9,f10],add_args=add_args)
 
-		for cnum,desc in (('1','incognito data'),('3','MMGen wallet')):
-			t.passphrase('{}'.format(desc),self.cfgs[cnum]['wpasswd'])
+		for cnum,wcls in (('1',IncogWallet),('3',Wallet)):
+			t.passphrase('{}'.format(wcls.desc),self.cfgs[cnum]['wpasswd'])
 
 		self.txsign_ui_common(t)
 		self.txsend_ui_common(t)
@@ -700,12 +719,13 @@ class TestSuiteMain(TestSuiteBase,TestSuiteShared):
 	def txcreate5(self,addrfile):
 		return self.txcreate_common(sources=['20'],non_mmgen_input='20',non_mmgen_input_compressed=False)
 
-	def txsign5(self,txf,wf,bad_vsize=True,add_args=[]):
+	def txsign5(self,wf,txf,bad_vsize=True,add_args=[]):
 		non_mm_file = joinpath(self.tmpdir,non_mmgen_fn)
 		t = self.spawn('mmgen-txsign', add_args + ['-d',self.tmpdir,'-k',non_mm_file,txf,wf])
 		t.license()
 		t.view_tx('n')
-		t.passphrase('MMGen wallet',self.cfgs['20']['wpasswd'])
+		wcls = SeedSource.ext_to_type(get_extension(wf))
+		t.passphrase(wcls.desc,self.cfgs['20']['wpasswd'])
 		if bad_vsize:
 			t.expect('Estimated transaction vsize')
 			t.expect('1 transaction could not be signed')

test/test_py_d/ts_ref.py

@@ -23,6 +23,7 @@ ts_ref.py: Reference file tests for the test.py test suite
 import os
 from mmgen.globalvars import g
 from mmgen.opts import opt
+from mmgen.seed import MMGenMnemonic
 from test.common import *
 from test.test_py_d.common import *
 
@@ -33,7 +34,7 @@ wpasswd = 'reference password'
 nw_name = '{} {}'.format(g.coin,('Mainnet','Testnet')[g.testnet])
 
 class TestSuiteRef(TestSuiteBase,TestSuiteShared):
-	'saved reference files'
+	'saved reference address, password and transaction files'
 	tmpdir_nums = [8]
 	networks = ('btc','btc_tn','ltc','ltc_tn')
 	passthru_opts = ('coin','testnet')
@@ -153,12 +154,13 @@ class TestSuiteRef(TestSuiteBase,TestSuiteShared):
 
 	def ref_words_to_subwallet_chk(self,ss_idx):
 		wf = dfl_words_file
-		args = ['-d',self.tr.trash_dir,'-o','words',wf,ss_idx]
+		ocls = MMGenMnemonic
+		args = ['-d',self.tr.trash_dir,'-o',ocls.fmt_codes[-1],wf,ss_idx]
 
 		t = self.spawn('mmgen-subwalletgen',args,extra_desc='(generate subwallet)')
 		t.expect('Generating subseed {}'.format(ss_idx))
 		chk_sid = self.chk_data['ref_subwallet_sid']['98831F3A:{}'.format(ss_idx)]
-		fn = t.written_to_file('MMGen native mnemonic data')
+		fn = t.written_to_file(capfirst(ocls.desc))
 		assert chk_sid in fn,'incorrect filename: {} (does not contain {})'.format(fn,chk_sid)
 		ok()
 
@@ -258,7 +260,7 @@ class TestSuiteRef(TestSuiteBase,TestSuiteShared):
 		wf = dfl_words_file
 		self.write_to_tmpfile(pwfile,wpasswd)
 		pf = joinpath(self.tmpdir,pwfile)
-		return self.txsign(tf,wf,pf,save=False,has_label=True,do_passwd=False,view='y')
+		return self.txsign(wf,tf,pf,save=False,has_label=True,view='y')
 
 	def ref_brain_chk_spc3(self):
 		return self.ref_brain_chk(bw_file=ref_bw_file_spc)

test/test_py_d/ts_ref_3seed.py

@@ -23,6 +23,7 @@ ts_ref_3seed.py: Saved and generated reference file tests for 128, 192 and
 
 from mmgen.globalvars import g
 from mmgen.opts import opt
+from mmgen.seed import SeedSource
 from test.common import *
 from test.test_py_d.common import *
 from test.test_py_d.ts_base import *
@@ -30,7 +31,7 @@ from test.test_py_d.ts_shared import *
 from test.test_py_d.ts_wallet import TestSuiteWalletConv
 
 class TestSuiteRef3Seed(TestSuiteBase,TestSuiteShared):
-	'saved and generated reference data for 128-, 192- and 256-bit seeds'
+	'saved wallet files for 128-, 192- and 256-bit seeds + generated filename checks'
 	networks = ('btc','btc_tn','ltc','ltc_tn')
 	passthru_opts = ('coin','testnet')
 	mmtypes = (None,)
@@ -42,24 +43,25 @@ class TestSuiteRef3Seed(TestSuiteBase,TestSuiteShared):
 		'sids': ('FE3C6545', '1378FC64', '98831F3A'),
 	}
 	cmd_group = (
-		# reading
-		('ref_wallet_chk', ([],'saved reference wallet')),
-		('ref_seed_chk',   ([],'saved seed file')),
-		('ref_hex_chk',    ([],'saved mmhex file')),
+		# reading saved reference wallets
+		('ref_wallet_chk',  ([],'saved reference wallet')),
+		('ref_seed_chk',    ([],'saved seed file')),
+		('ref_hex_chk',     ([],'saved mmhex file')),
 		('ref_plainhex_chk',([],'saved hex file')),
-		('ref_mn_chk',     ([],'saved native MMGen mnemonic file')),
-		('ref_bip39_chk',  ([],'saved BIP39 mnemonic file')),
-		('ref_hincog_chk', ([],'saved hidden incog reference wallet')),
-		('ref_brain_chk',  ([],'saved brainwallet')), # in ts_shared
-		# generating new reference ('abc' brainwallet) files:
-		('ref_walletgen_brain',   ([],'generating new reference wallet + filename check (brain)')),
-		('ref_walletconv_words',  (['mmdat',pwfile],'wallet filename (native mnemonic)')),
-		('ref_walletconv_bip39',  (['mmdat',pwfile],'wallet filename (bip39)')),
-		('ref_walletconv_seed',   (['mmdat',pwfile],'wallet filename (seed)')),
-		('ref_walletconv_hexseed',(['mmdat',pwfile],'wallet filename (hex seed)')),
-		('ref_walletconv_plainhexseed',(['mmdat',pwfile],'wallet filename (plain hex seed)')),
-		('ref_walletconv_incog',  (['mmdat',pwfile],'wallet filename (incog)')),
-		('ref_walletconv_xincog', (['mmdat',pwfile],'wallet filename (hex incog)')),
+		('ref_mn_chk',      ([],'saved native MMGen mnemonic file')),
+		('ref_bip39_chk',   ([],'saved BIP39 mnemonic file')),
+		('ref_hincog_chk',  ([],'saved hidden incog reference wallet')),
+		('ref_brain_chk',   ([],'saved brainwallet')), # in ts_shared
+
+		# generating new reference ('abc' brainwallet) wallets for filename checks:
+		('ref_walletgen_brain',        ([],'generating new reference wallet + filename check (brain)')),
+		('ref_walletconv_words',       ([],'wallet filename (native mnemonic)')),
+		('ref_walletconv_bip39',       ([],'wallet filename (bip39)')),
+		('ref_walletconv_seed',        ([],'wallet filename (seed)')),
+		('ref_walletconv_hexseed',     ([],'wallet filename (hex seed)')),
+		('ref_walletconv_plainhexseed',([],'wallet filename (plain hex seed)')),
+		('ref_walletconv_incog',       ([],'wallet filename (incog)')),
+		('ref_walletconv_xincog',      ([],'wallet filename (hex incog)')),
 	)
 
 	def __init__(self,trunner,cfgs,spawn):
@@ -74,11 +76,11 @@ class TestSuiteRef3Seed(TestSuiteBase,TestSuiteShared):
 
 	def ref_wallet_chk(self):
 		wf = joinpath(ref_dir,TestSuiteWalletConv.sources[str(self.seed_len)]['ref_wallet'])
-		return self.walletchk(wf,pf=None,pw=True,sid=self.seed_id)
+		return self.walletchk(wf,pf=None,sid=self.seed_id)
 
 	def ref_ss_chk(self,ss=None):
 		wf = joinpath(ref_dir,'{}.{}'.format(self.seed_id,ss.ext))
-		return self.walletchk(wf,pf=None,desc=ss.desc,sid=self.seed_id)
+		return self.walletchk(wf,pf=None,wcls=ss,sid=self.seed_id)
 
 	def ref_seed_chk(self):
 		from mmgen.seed import MMGenSeedFile
@@ -132,9 +134,10 @@ class TestSuiteRef3Seed(TestSuiteBase,TestSuiteShared):
 		t = self.spawn('mmgen-walletconv', args + [self.usr_rand_arg])
 		t.license()
 		t.expect('Enter brainwallet: ', ref_wallet_brainpass+'\n')
-		t.passphrase_new('new MMGen wallet',self.wpasswd)
+		ocls = Wallet
+		t.passphrase_new('new '+ocls.desc,self.wpasswd)
 		t.usr_rand(self.usr_rand_chars)
-		fn = os.path.split(t.written_to_file('MMGen wallet'))[-1]
+		fn = os.path.split(t.written_to_file(capfirst(ocls.desc)))[-1]
 		import re
 		idx = int(self.test_name[-1]) - 1
 		pat = r'{}-[0-9A-F]{{8}}\[{},1\].mmdat'.format(
@@ -145,44 +148,39 @@ class TestSuiteRef3Seed(TestSuiteBase,TestSuiteShared):
 		cmp_or_die(sid,self.seed_id,desc='Seed ID')
 		return t
 
-	def ref_walletconv(self,fn,pf,ofmt,desc,ext,extra_args=[],re_pat=None):
-		t = self.spawn('mmgen-walletconv',extra_args+['-d','test/trash','-o',ofmt,'-P'+pf,fn])
-		fn = os.path.split(t.written_to_file(desc))[-1]
+	def ref_walletconv(self,ofmt,extra_args=[],re_pat=None):
+		wf = self.get_file_with_ext('mmdat')
+		pf = joinpath(self.tmpdir,pwfile)
+		t = self.spawn('mmgen-walletconv',extra_args+['-d','test/trash','-o',ofmt,'-P'+pf,wf])
+		wcls = SeedSource.fmt_code_to_type(ofmt)
+		fn = os.path.split(t.written_to_file(capfirst(wcls.desc)))[-1]
 		idx = int(self.test_name[-1]) - 1
 		sid = self.chk_data['sids'][idx]
 		slen = self.chk_data['lens'][idx]
 		if re_pat:
 			import re
-			assert re.match(re_pat.format(sid,slen),fn)
+			pat = re_pat.format(sid,slen)
+			assert re.match(pat,fn),'{} {}'.format(pat,fn)
 		else:
-			cmp_or_die('{}[{}].{}'.format(sid,slen,ext),fn)
+			cmp_or_die('{}[{}].{}'.format(sid,slen,wcls.ext),fn)
 		return t
 
-	def ref_walletconv_words(self,fn,pf):
-		return self.ref_walletconv(fn,pf,ofmt='mn',desc='MMGen native mnemonic data',ext='mmwords')
+	def ref_walletconv_words(self):        return self.ref_walletconv(ofmt='mn')
+	def ref_walletconv_bip39(self):        return self.ref_walletconv(ofmt='bip39')
+	def ref_walletconv_seed(self):         return self.ref_walletconv(ofmt='mmseed')
+	def ref_walletconv_hexseed(self):      return self.ref_walletconv(ofmt='mmhex')
+	def ref_walletconv_plainhexseed(self): return self.ref_walletconv(ofmt='hex')
 
-	def ref_walletconv_bip39(self,fn,pf):
-		return self.ref_walletconv(fn,pf,ofmt='bip39',desc='BIP39 mnemonic data',ext='bip39')
-
-	def ref_walletconv_seed(self,fn,pf):
-		return self.ref_walletconv(fn,pf,ofmt='mmseed',desc='Seed data',ext='mmseed')
-
-	def ref_walletconv_hexseed(self,fn,pf):
-		return self.ref_walletconv(fn,pf,ofmt='mmhex',desc='Hexadecimal seed data with checksum',ext='mmhex')
-
-	def ref_walletconv_plainhexseed(self,fn,pf):
-		return self.ref_walletconv(fn,pf,ofmt='hex',desc='Plain hexadecimal seed data',ext='hex')
-
-	def ref_walletconv_incog(self,fn,pf,desc='Incognito data',ofmt='incog',ext='mmincog'):
+	def ref_walletconv_incog(self,ofmt='incog',ext='mmincog'):
 		args = ['-r0','-p1']
 		pat = r'{}-[0-9A-F]{{8}}-[0-9A-F]{{8}}\[{},1\].' + ext
-		return self.ref_walletconv(fn,pf,ofmt=ofmt,desc=desc,ext=ext,extra_args=args,re_pat=pat)
+		return self.ref_walletconv(ofmt=ofmt,extra_args=args,re_pat=pat)
 
-	def ref_walletconv_xincog(self,fn,pf):
-		return self.ref_walletconv_incog(fn,pf,desc='Hex incognito data',ofmt='incog_hex',ext='mmincox')
+	def ref_walletconv_xincog(self):
+		return self.ref_walletconv_incog(ofmt='incog_hex',ext='mmincox')
 
 class TestSuiteRef3Addr(TestSuiteRef3Seed):
-	'generated reference address, key and passwd files for 128-, 192- and 256-bit seeds'
+	'generated reference address, key and password files for 128-, 192- and 256-bit seeds'
 	tmpdir_nums = [26,27,28]
 
 	chk_data = {
@@ -314,78 +312,71 @@ class TestSuiteRef3Addr(TestSuiteRef3Seed):
 	}
 
 	cmd_group = (
-		('ref_walletgen_brain',  ([],'generating new reference wallet + filename check (brain)')),
-		('refpasswdgen',         (['mmdat',pwfile],'new refwallet passwd file chksum')),
-		('refpasswdgen_half',    (['mmdat',pwfile],'new refwallet passwd file chksum (half-length)')),
-		('ref_b32passwdgen',     (['mmdat',pwfile],'new refwallet passwd file chksum (base32)')),
-		('ref_hexpasswdgen',     (['mmdat',pwfile],'new refwallet passwd file chksum (hex)')),
-		('ref_hexpasswdgen_half',(['mmdat',pwfile],'new refwallet passwd file chksum (hex, half-length)')),
-		('ref_bip39_12_passwdgen',(['mmdat',pwfile],'new refwallet passwd file chksum (BIP39, 12 words)')),
-		('ref_bip39_18_passwdgen',(['mmdat',pwfile],'new refwallet passwd file chksum (BIP39, up to 18 words)')),
-		('ref_bip39_24_passwdgen',(['mmdat',pwfile],'new refwallet passwd file chksum (BIP39, up to 24 words)')),
-		('ref_hex2bip39_24_passwdgen',(['mmdat',pwfile],'new refwallet passwd file chksum (hex-to-BIP39, up to 24 words)')),
-		('refaddrgen_legacy',     (['mmdat',pwfile],'new refwallet addr chksum (uncompressed)')),
-		('refaddrgen_compressed',     (['mmdat',pwfile],'new refwallet addr chksum (compressed)')),
-		('refaddrgen_segwit',     (['mmdat',pwfile],'new refwallet addr chksum (segwit)')),
-		('refaddrgen_bech32',     (['mmdat',pwfile],'new refwallet addr chksum (bech32)')),
-		('refkeyaddrgen_legacy',  (['mmdat',pwfile],'new refwallet key-addr chksum (uncompressed)')),
-		('refkeyaddrgen_compressed', (['mmdat',pwfile],'new refwallet key-addr chksum (compressed)')),
-		('refkeyaddrgen_segwit', (['mmdat',pwfile],'new refwallet key-addr chksum (segwit)')),
-		('refkeyaddrgen_bech32', (['mmdat',pwfile],'new refwallet key-addr chksum (bech32)')),
+		('ref_walletgen_brain',       ([],'generating new reference wallet + filename check (brain)')),
+		('refaddrgen_legacy',         ([],'new refwallet addr chksum (uncompressed)')),
+		('refaddrgen_compressed',     ([],'new refwallet addr chksum (compressed)')),
+		('refaddrgen_segwit',         ([],'new refwallet addr chksum (segwit)')),
+		('refaddrgen_bech32',         ([],'new refwallet addr chksum (bech32)')),
+		('refkeyaddrgen_legacy',      ([],'new refwallet key-addr chksum (uncompressed)')),
+		('refkeyaddrgen_compressed',  ([],'new refwallet key-addr chksum (compressed)')),
+		('refkeyaddrgen_segwit',      ([],'new refwallet key-addr chksum (segwit)')),
+		('refkeyaddrgen_bech32',      ([],'new refwallet key-addr chksum (bech32)')),
+		('refpasswdgen',              ([],'new refwallet passwd file chksum')),
+		('refpasswdgen_half',         ([],'new refwallet passwd file chksum (half-length)')),
+		('ref_b32passwdgen',          ([],'new refwallet passwd file chksum (base32)')),
+		('ref_hexpasswdgen',          ([],'new refwallet passwd file chksum (hex)')),
+		('ref_hexpasswdgen_half',     ([],'new refwallet passwd file chksum (hex, half-length)')),
+		('ref_bip39_12_passwdgen',    ([],'new refwallet passwd file chksum (BIP39, 12 words)')),
+		('ref_bip39_18_passwdgen',    ([],'new refwallet passwd file chksum (BIP39, up to 18 words)')),
+		('ref_bip39_24_passwdgen',    ([],'new refwallet passwd file chksum (BIP39, up to 24 words)')),
+		('ref_hex2bip39_24_passwdgen',([],'new refwallet passwd file chksum (hex-to-BIP39, up to 24 words)')),
 	)
 
-	def refaddrgen_legacy(self,wf,pf):
-		return self.addrgen(wf,pf=pf,check_ref=True,mmtype='legacy')
-
-	def refaddrgen_compressed(self,wf,pf):
-		return self.addrgen(wf,pf=pf,check_ref=True,mmtype='compressed')
-
-	def refaddrgen_segwit(self,wf,pf):
-		return self.addrgen(wf,pf=pf,check_ref=True,mmtype='segwit')
-
-	def refaddrgen_bech32(self,wf,pf):
-		return self.addrgen(wf,pf=pf,check_ref=True,mmtype='bech32')
-
-	def refkeyaddrgen_legacy(self,wf,pf,mmtype='legacy'):
-		return self.keyaddrgen(wf,pf,check_ref=True)
-
-	def refkeyaddrgen_compressed(self,wf,pf):
-		return self.keyaddrgen(wf,pf=pf,check_ref=True,mmtype='compressed')
-
-	def refkeyaddrgen_segwit(self,wf,pf):
-		return self.keyaddrgen(wf,pf=pf,check_ref=True,mmtype='segwit')
-
-	def refkeyaddrgen_bech32(self,wf,pf):
-		return self.keyaddrgen(wf,pf=pf,check_ref=True,mmtype='bech32')
-
-	def refpasswdgen(self,wf,pf):
-		return self.addrgen(wf,pf,check_ref=True,ftype='pass',id_str='alice@crypto.org')
-
-	def refpasswdgen_half(self,wf,pf):
-		ea = ['--passwd-len=h']
-		return self.addrgen(wf,pf,check_ref=True,ftype='pass',id_str='alice@crypto.org',extra_args=ea)
-
-	def ref_b32passwdgen(self,wf,pf):
-		ea = ['--passwd-fmt=b32','--passwd-len=17']
-		return self.addrgen(wf,pf,check_ref=True,ftype='pass32',id_str='фубар@crypto.org',extra_args=ea)
-
-	def ref_hexpasswdgen(self,wf,pf):
-		pw_len = {'1':32,'2':48,'3':64}[self.test_name[-1]]
-		ea = ['--passwd-fmt=hex','--passwd-len={}'.format(pw_len)]
-		return self.addrgen(wf,pf,check_ref=True,ftype='passhex',id_str='фубар@crypto.org',extra_args=ea)
-
-	def ref_hexpasswdgen_half(self,wf,pf):
-		ea = ['--passwd-fmt=hex','--passwd-len=h','--accept-defaults']
-		return self.addrgen(wf,pf,check_ref=True,ftype='passhex',id_str='фубар@crypto.org',extra_args=ea,stdout=1)
-
-	def ref_bip39_passwdgen(self,wf,pf,req_pw_len,pw_fmt='bip39',stdout=False):
-		pw_len = min(req_pw_len,{'1':12,'2':18,'3':24}[self.test_name[-1]])
-		ea = ['--passwd-fmt='+pw_fmt,'--passwd-len={}'.format(pw_len),'--accept-defaults']
-		return self.addrgen(
-			wf,pf,check_ref=True,ftype='passbip39',id_str='фубар@crypto.org',extra_args=ea,stdout=stdout)
-
-	def ref_bip39_12_passwdgen(self,wf,pf): return self.ref_bip39_passwdgen(wf,pf,12,stdout=True)
-	def ref_bip39_18_passwdgen(self,wf,pf): return self.ref_bip39_passwdgen(wf,pf,18,stdout=True)
-	def ref_bip39_24_passwdgen(self,wf,pf): return self.ref_bip39_passwdgen(wf,pf,24)
-
-	def ref_hex2bip39_24_passwdgen(self,wf,pf): return self.ref_bip39_passwdgen(wf,pf,24,'hex2bip39')
+	def call_addrgen(self,mmtype,pfx='addr'):
+		wf = self.get_file_with_ext('mmdat')
+		pf = joinpath(self.tmpdir,pwfile)
+		return getattr(self,pfx+'gen')(wf,pf=pf,check_ref=True,mmtype=mmtype)
+
+	def refaddrgen_legacy(self):        return self.call_addrgen('legacy')
+	def refaddrgen_compressed(self):    return self.call_addrgen('compressed')
+	def refaddrgen_segwit(self):        return self.call_addrgen('segwit')
+	def refaddrgen_bech32(self):        return self.call_addrgen('bech32')
+
+	def refkeyaddrgen_legacy(self):     return self.call_addrgen('legacy','keyaddr')
+	def refkeyaddrgen_compressed(self): return self.call_addrgen('compressed','keyaddr')
+	def refkeyaddrgen_segwit(self):     return self.call_addrgen('segwit','keyaddr')
+	def refkeyaddrgen_bech32(self):     return self.call_addrgen('bech32','keyaddr')
+
+	def pwgen(self,ftype,id_str,pwfmt=None,pwlen=None,extra_args=[],stdout=False):
+		wf = self.get_file_with_ext('mmdat')
+		pf = joinpath(self.tmpdir,pwfile)
+		pwfmt = (['--passwd-fmt='+pwfmt] if pwfmt else [])
+		pwlen = (['--passwd-len='+str(pwlen)] if pwlen else [])
+		return self.addrgen(wf, pf,
+					check_ref  = True,
+					ftype      = ftype,
+					id_str     = id_str,
+					extra_args = pwfmt + pwlen + extra_args,
+					stdout     = stdout )
+
+	def refpasswdgen(self):      return self.pwgen('pass','alice@crypto.org')
+	def refpasswdgen_half(self): return self.pwgen('pass','alice@crypto.org',pwlen='h')
+	def ref_b32passwdgen(self):  return self.pwgen('pass32','фубар@crypto.org','b32',17)
+
+	def ref_hexpasswdgen(self):
+		pwlen = {'1':32,'2':48,'3':64}[self.test_name[-1]]
+		return self.pwgen('passhex','фубар@crypto.org','hex',pwlen)
+
+	def ref_hexpasswdgen_half(self):
+		ea = ['--accept-defaults']
+		return self.pwgen('passhex','фубар@crypto.org','hex','h',ea,stdout=True)
+
+	def bip39pwgen(self,req_pw_len,pwfmt='bip39',stdout=False):
+		pwlen = min(req_pw_len,{'1':12,'2':18,'3':24}[self.test_name[-1]])
+		ea = ['--accept-defaults']
+		return self.pwgen('passbip39','фубар@crypto.org',pwfmt,pwlen,ea,stdout=stdout)
+
+	def ref_bip39_12_passwdgen(self):     return self.bip39pwgen(12,stdout=True)
+	def ref_bip39_18_passwdgen(self):     return self.bip39pwgen(18,stdout=True)
+	def ref_bip39_24_passwdgen(self):     return self.bip39pwgen(24)
+	def ref_hex2bip39_24_passwdgen(self): return self.bip39pwgen(24,'hex2bip39')

test/test_py_d/ts_ref_altcoin.py

@@ -96,10 +96,9 @@ class TestSuiteRefAltcoin(TestSuiteRef,TestSuiteBase):
 				wf = dfl_words_file
 				e = ['--coin='+coin,'--testnet='+('0','1')[tn]]
 				if token: e += ['--token='+token]
-				t = self.txsign(tf, wf, pf,
+				t = self.txsign(wf, tf, pf,
 								save       = False,
 								has_label  = True,
-								do_passwd  = False,
 								extra_desc = '({}{})'.format(token or coin,' testnet' if tn else ''),
 								extra_opts = e )
 				ok_msg()

test/test_py_d/ts_regtest.py

@@ -28,9 +28,11 @@ from mmgen.opts import opt
 from mmgen.util import die,gmsg,write_data_to_file
 from mmgen.protocol import CoinProtocol
 from mmgen.addr import AddrList
+from mmgen.seed import Wallet
 from test.common import *
 from test.test_py_d.common import *
 
+dfl_wcls = Wallet
 rt_pw = 'abc-α'
 rt_data = {
 	'tx_fee': {'btc':'0.0001','bch':'0.001','ltc':'0.01'},
@@ -262,10 +264,10 @@ class TestSuiteRegtest(TestSuiteBase,TestSuiteShared):
 
 	def walletgen(self,user):
 		t = self.spawn('mmgen-walletgen',['-q','-r0','-p1','--'+user])
-		t.passphrase_new('new MMGen wallet',rt_pw)
+		t.passphrase_new('new '+dfl_wcls.desc,rt_pw)
 		t.label()
 		t.expect('move it to the data directory? (Y/n): ','y')
-		t.written_to_file('MMGen wallet')
+		t.written_to_file(capfirst(dfl_wcls.desc))
 		return t
 
 	def walletgen_bob(self):   return self.walletgen('bob')
@@ -282,9 +284,10 @@ class TestSuiteRegtest(TestSuiteBase,TestSuiteShared):
 		if subseed_idx in self.usr_subsids[user]:
 			return self.usr_subsids[user][subseed_idx]
 
-		fn = get_file_with_ext(self._user_dir(user),'mmdat')
+		icls = Wallet
+		fn = get_file_with_ext(self._user_dir(user),icls.ext)
 		t = self.spawn('mmgen-tool',['get_subseed',subseed_idx,'wallet='+fn],no_msg=True)
-		t.passphrase('MMGen wallet',rt_pw)
+		t.passphrase(icls.desc,rt_pw)
 		sid = t.read().strip()[:8]
 		self.usr_subsids[user][subseed_idx] = sid
 		return sid
@@ -298,7 +301,7 @@ class TestSuiteRegtest(TestSuiteBase,TestSuiteShared):
 				(['--subwallet='+subseed_idx] if subseed_idx else []) +
 				[addr_range],
 				extra_desc='({})'.format(MMGenAddrType.mmtypes[mmtype].name))
-			t.passphrase('MMGen wallet',rt_pw)
+			t.passphrase(dfl_wcls.desc,rt_pw)
 			t.written_to_file('Addresses')
 			ok_msg()
 		t.skip_ok = True
@@ -451,7 +454,7 @@ class TestSuiteRegtest(TestSuiteBase,TestSuiteShared):
 		fn = get_file_with_ext(self.tmpdir,'rawtx')
 		t = self.spawn('mmgen-txsign',['-d',self.tmpdir,'--bob','--subseeds=127',fn])
 		t.view_tx('t')
-		t.passphrase('MMGen wallet',rt_pw)
+		t.passphrase(dfl_wcls.desc,rt_pw)
 		t.do_comment(None)
 		t.expect('(Y/n): ','y')
 		t.written_to_file('Signed transaction')
@@ -524,7 +527,7 @@ class TestSuiteRegtest(TestSuiteBase,TestSuiteShared):
 								add_comment     = tx_label_jp,
 								view            = 't',save=True)
 
-		t.passphrase('MMGen wallet',rt_pw)
+		t.passphrase(dfl_wcls.desc,rt_pw)
 		t.written_to_file('Signed transaction')
 		self._do_confirm_send(t)
 		s,exit_val = (('Transaction sent',0),("can't be included",1))[bad_locktime]
@@ -597,7 +600,7 @@ class TestSuiteRegtest(TestSuiteBase,TestSuiteShared):
 		t.expect('OK? (Y/n): ','y') # fee OK?
 		t.do_comment(False,has_label=has_label)
 		if signed_tx:
-			t.passphrase('MMGen wallet',rt_pw)
+			t.passphrase(dfl_wcls.desc,rt_pw)
 			t.written_to_file('Signed transaction')
 			self.txsend_ui_common(t,caller='txdo',bogus_send=False,file_desc='Signed transaction')
 		else:

test/test_py_d/ts_seedsplit.py

@@ -22,6 +22,7 @@ ts_seedsplit.py: Seed split/join tests for the test.py test suite
 
 from mmgen.globalvars import g
 from mmgen.opts import opt
+from mmgen.seed import SeedSource,Wallet,IncogWallet,IncogWalletHex,IncogWalletHidden,SeedSourceEnc
 
 from test.test_py_d.ts_base import *
 
@@ -29,6 +30,7 @@ ref_wf = 'test/ref/98831F3A.bip39'
 ref_sid = '98831F3A'
 wpasswd = 'abc'
 sh1_passwd = 'xyz'
+dfl_wcls = Wallet
 
 class TestSuiteSeedSplit(TestSuiteBase):
 	'splitting and joining seeds'
@@ -82,11 +84,11 @@ class TestSuiteSeedSplit(TestSuiteBase):
 
 	def ss_walletgen(self):
 		t = self.spawn('mmgen-walletgen', ['-r0','-p1'])
-		t.passphrase_new('new MMGen wallet',wpasswd)
+		t.passphrase_new('new '+dfl_wcls.desc,wpasswd)
 		t.label()
 		self.write_to_tmpfile('dfl.sid',t.expect_getend('Seed ID: '))
 		t.expect('move it to the data directory? (Y/n): ','y')
-		t.written_to_file('MMGen wallet')
+		t.written_to_file(capfirst(dfl_wcls.desc))
 		return t
 
 	def ss_splt(self,tdir,ofmt,spec,add_args=[],wf=None,master=None):
@@ -100,7 +102,7 @@ class TestSuiteSeedSplit(TestSuiteBase):
 				+ ([wf] if wf else [])
 				+ ([spec] if spec else []))
 		if not wf:
-			t.passphrase('MMGen wallet',wpasswd)
+			t.passphrase(dfl_wcls.desc,wpasswd)
 		if spec:
 			from mmgen.obj import SeedSplitSpecifier
 			sss = SeedSplitSpecifier(spec)
@@ -108,18 +110,14 @@ class TestSuiteSeedSplit(TestSuiteBase):
 		else:
 			pat = "master share #{}".format(master)
 		t.expect(pat,regex=True)
-		if ofmt in ('w','incog','incog_hex','hincog'):
-			desc = {'w':         'MMGen wallet',
-					'incog':     'incognito data',
-					'incog_hex': 'hex incognito data',
-					'hincog':    'hidden incognito data' }[ofmt]
-			t.hash_preset('new '+desc,'1')
-			t.passphrase_new('new '+desc,sh1_passwd)
-			if desc == 'hidden incognito data':
+		ocls = SeedSource.fmt_code_to_type(ofmt)
+		pw = issubclass(ocls,SeedSourceEnc)
+		if pw:
+			t.hash_preset('new '+ocls.desc,'1')
+			t.passphrase_new('new '+ocls.desc,sh1_passwd)
+			if ocls == IncogWalletHidden:
 				t.hincog_create(1234)
-			t.written_to_file(capfirst(desc))
-		else:
-			t.written_to_file('with checksum' if ofmt == 'mmhex' else 'data')
+		t.written_to_file(capfirst(ocls.desc))
 		return t
 
 	def ss_join(self,tdir,ofmt,in_exts,add_args=[],sid=None,bad_invocation=False,master=None,id_str=None):
@@ -137,26 +135,26 @@ class TestSuiteSeedSplit(TestSuiteBase):
 		if bad_invocation:
 			t.read()
 			return t
-		w_enc   = ( 'MMGen wallet' if 'mmdat' in in_exts else
-					'incognito data' if 'mmincog' in in_exts else
-					'hex incognito data' if 'mmincox' in in_exts else
-					'hidden incognito data' if '-H' in add_args else '')
-		if 'incognito' in w_enc:
-			t.hash_preset(w_enc,'1')
-		if w_enc:
-			t.passphrase(w_enc,sh1_passwd)
+		icls = ( Wallet if 'mmdat' in in_exts
+			else IncogWallet if 'mmincog' in in_exts
+			else IncogWalletHex if 'mmincox' in in_exts
+			else IncogWalletHidden if '-H' in add_args
+			else None )
+		if icls in (IncogWallet,IncogWalletHex,IncogWalletHidden):
+			t.hash_preset(icls.desc,'1')
+		if icls:
+			t.passphrase(icls.desc,sh1_passwd)
 		if master:
 			fs = "master share #{}, split id '{}', share count {}"
-			pat = fs.format(master,id_str or 'default',len(shares)+('hidden' in w_enc))
+			pat = fs.format(master,id_str or 'default',len(shares)+(icls==IncogWalletHidden))
 			t.expect(pat,regex=True)
 		sid_cmp = t.expect_getend('Joined Seed ID: ')
 		cmp_or_die(sid,sid_cmp)
-		if ofmt == 'w':
-			t.hash_preset('new MMGen wallet','1')
-			t.passphrase_new('new MMGen wallet',wpasswd)
-			t.written_to_file('MMGen wallet')
-		else:
-			t.written_to_file('with checksum' if ofmt == 'mmhex' else 'data')
+		ocls = SeedSource.fmt_code_to_type(ofmt)
+		if ocls == Wallet:
+			t.hash_preset('new '+ocls.desc,'1')
+			t.passphrase_new('new '+ocls.desc,wpasswd)
+		t.written_to_file(capfirst(ocls.desc))
 		return t
 
 	def get_hincog_arg(self,tdir,suf='-default-2of2'):

test/test_py_d/ts_shared.py

@@ -24,6 +24,7 @@ import os
 from mmgen.globalvars import g
 from mmgen.opts import opt
 from mmgen.util import ymsg
+from mmgen.seed import SeedSource,SeedSourceEnc,Brainwallet,Wallet,IncogWalletHidden
 from test.test_py_d.common import *
 from test.common import *
 
@@ -144,20 +145,23 @@ class TestSuiteShared(object):
 		t.written_to_file('Signed transaction' + (' #' + tnum if tnum else ''), oo=True)
 		return t
 
-	def txsign( self, txfile, wf,
+	def txsign( self, wf, txfile,
 				pf         = '',
 				bumpf      = '',
 				save       = True,
 				has_label  = False,
-				do_passwd  = True,
 				extra_opts = [],
 				extra_desc = '',
-				view       = 'n'):
+				view       = 'n',
+				dfl_wallet = False ):
 		opts = extra_opts + ['-d',self.tmpdir,txfile] + ([wf] if wf else [])
 		t = self.spawn('mmgen-txsign', opts, extra_desc)
 		t.license()
 		t.view_tx(view)
-		if do_passwd: t.passphrase('MMGen wallet',self.wpasswd)
+		wcls = Wallet if dfl_wallet else SeedSource.ext_to_type(get_extension(wf))
+		pw = issubclass(wcls,SeedSourceEnc) and wcls != Brainwallet
+		if pw:
+			t.passphrase(wcls.desc,self.wpasswd)
 		if save:
 			self.txsign_end(t,has_label=has_label)
 		else:
@@ -169,26 +173,35 @@ class TestSuiteShared(object):
 	def ref_brain_chk(self,bw_file=ref_bw_file):
 		wf = joinpath(ref_dir,bw_file)
 		add_args = ['-l{}'.format(self.seed_len), '-p'+ref_bw_hash_preset]
-		return self.walletchk(wf,pf=None,add_args=add_args,
-			desc='brainwallet',sid=self.ref_bw_seed_id)
+		return self.walletchk(wf,pf=None,add_args=add_args,sid=self.ref_bw_seed_id)
 
-	def walletchk(self,wf,pf,desc='MMGen wallet',add_args=[],sid=None,pw=False,extra_desc=''):
-		args = []
+	def walletchk(self,wf,pf,wcls=None,add_args=[],sid=None,extra_desc='',dfl_wallet=False):
 		hp = self.hash_preset if hasattr(self,'hash_preset') else '1'
-		wf_arg = [wf] if wf else []
+		wcls = wcls or SeedSource.ext_to_type(get_extension(wf))
 		t = self.spawn('mmgen-walletchk',
-				add_args+args+['-p',hp]+wf_arg,
+				([] if dfl_wallet else ['-i',wcls.fmt_codes[0]])
+				+ add_args + ['-p',hp]
+				+ ([wf] if wf else []),
 				extra_desc=extra_desc)
-		if desc != 'hidden incognito data':
-			t.expect("Getting {} from file '".format(desc))
+		if wcls != IncogWalletHidden:
+			t.expect("Getting {} from file '".format(wcls.desc))
+		pw = issubclass(wcls,SeedSourceEnc) and wcls != Brainwallet
 		if pw:
-			t.passphrase(desc,self.wpasswd)
+			t.passphrase(wcls.desc,self.wpasswd)
 			t.expect(['Passphrase is OK', 'Passphrase.* are correct'],regex=True)
-		chk = t.expect_getend('Valid {} for Seed ID '.format(desc))[:8]
+		chk = t.expect_getend('Valid {} for Seed ID '.format(wcls.desc))[:8]
 		if sid: cmp_or_die(chk,sid)
 		return t
 
-	def addrgen(self,wf,pf=None,check_ref=False,ftype='addr',id_str=None,extra_args=[],mmtype=None,stdout=False):
+	def addrgen(self,wf,
+				pf         = None,
+				check_ref  = False,
+				ftype      = 'addr',
+				id_str     = None,
+				extra_args = [],
+				mmtype     = None,
+				stdout     = False,
+				dfl_wallet = False ):
 		passgen = ftype[:4] == 'pass'
 		if not mmtype and not passgen:
 			mmtype = self.segwit_mmtype
@@ -202,7 +215,8 @@ class TestSuiteShared(object):
 				[getattr(self,'{}_idx_list'.format(cmd_pfx))],
 				extra_desc='({})'.format(mmtype) if mmtype in ('segwit','bech32') else '')
 		t.license()
-		t.passphrase('MMGen wallet',self.wpasswd)
+		wcls = Wallet if dfl_wallet else SeedSource.ext_to_type(get_extension(wf))
+		t.passphrase(wcls.desc,self.wpasswd)
 		t.expect('Passphrase is OK')
 		desc = ('address','password')[passgen]
 		chk = t.expect_getend(r'Checksum for {} data .*?: '.format(desc),regex=True)
@@ -223,7 +237,8 @@ class TestSuiteShared(object):
 				([],['--type='+str(mmtype)])[bool(mmtype)] + args,
 				extra_desc='({})'.format(mmtype) if mmtype in ('segwit','bech32') else '')
 		t.license()
-		t.passphrase('MMGen wallet',self.wpasswd)
+		wcls = SeedSource.ext_to_type(get_extension(wf))
+		t.passphrase(wcls.desc,self.wpasswd)
 		chk = t.expect_getend(r'Checksum for key-address data .*?: ',regex=True)
 		if check_ref:
 			chk_ref = self.chk_data[self.test_name][self.fork][g.testnet]

test/test_py_d/ts_wallet.py

@@ -22,6 +22,7 @@ ts_wallet.py: Wallet conversion tests for the test.py test suite
 
 import os
 from mmgen.opts import opt
+from mmgen.seed import *
 from test.test_py_d.common import *
 from test.test_py_d.ts_base import *
 from test.test_py_d.ts_shared import *
@@ -90,77 +91,55 @@ class TestSuiteWalletConv(TestSuiteBase,TestSuiteShared):
 
 	def ref_wallet_conv(self):
 		wf = joinpath(ref_dir,self.sources[str(self.seed_len)]['ref_wallet'])
-		return self.walletconv_in(wf,'MMGen wallet',pw=True,oo=True)
+		return self.walletconv_in(wf,oo=True)
 
-	def ref_mn_conv(self,ext='mmwords',desc='MMGen native mnemonic data'):
+	def ref_mn_conv(self,ext='mmwords'):
 		wf = joinpath(ref_dir,self.seed_id+'.'+ext)
-		return self.walletconv_in(wf,desc,oo=True)
+		return self.walletconv_in(wf,oo=True)
 
-	def ref_bip39_conv(self):
-		return self.ref_mn_conv(ext='bip39',desc='BIP39 mnemonic data')
-
-	def ref_seed_conv(self):
-		return self.ref_mn_conv(ext='mmseed',desc='Seed data')
-
-	def ref_hex_conv(self):
-		return self.ref_mn_conv(ext='mmhex',desc='Hexadecimal seed data with checksum')
-
-	def ref_plainhex_conv(self):
-		return self.ref_mn_conv(ext='hex',desc='Plain hexadecimal seed data')
+	def ref_bip39_conv(self):    return self.ref_mn_conv(ext='bip39')
+	def ref_seed_conv(self):     return self.ref_mn_conv(ext='mmseed')
+	def ref_hex_conv(self):      return self.ref_mn_conv(ext='mmhex')
+	def ref_plainhex_conv(self): return self.ref_mn_conv(ext='hex')
 
 	def ref_brain_conv(self):
 		uopts = ['-i','b','-p','1','-l',str(self.seed_len)]
-		return self.walletconv_in(None,'brainwallet',uopts,oo=True)
+		return self.walletconv_in(None,uopts,oo=True,icls=Brainwallet)
 
-	def ref_incog_conv(self,wfk='ic_wallet',in_fmt='i',desc='incognito data'):
+	def ref_incog_conv(self,wfk='ic_wallet',in_fmt='i'):
 		uopts = ['-i',in_fmt,'-p','1','-l',str(self.seed_len)]
 		wf = joinpath(ref_dir,self.sources[str(self.seed_len)][wfk])
-		return self.walletconv_in(wf,desc,uopts,oo=True,pw=True)
+		return self.walletconv_in(wf,uopts,oo=True)
 
 	def ref_incox_conv(self):
-		return self.ref_incog_conv(in_fmt='xi',wfk='ic_wallet_hex',desc='hex incognito data')
+		return self.ref_incog_conv(in_fmt='xi',wfk='ic_wallet_hex')
 
 	def ref_hincog_conv(self,wfk='hic_wallet',add_uopts=[]):
 		ic_f = joinpath(ref_dir,self.sources[str(self.seed_len)][wfk])
 		uopts = ['-i','hi','-p','1','-l',str(self.seed_len)] + add_uopts
 		hi_opt = ['-H','{},{}'.format(ic_f,ref_wallet_incog_offset)]
-		return self.walletconv_in(None,'hidden incognito data',uopts+hi_opt,oo=True,pw=True)
+		return self.walletconv_in(None,uopts+hi_opt,oo=True,icls=IncogWalletHidden)
 
 	def ref_hincog_conv_old(self):
 		return self.ref_hincog_conv(wfk='hic_wallet_old',add_uopts=['-O'])
 
-	def ref_wallet_conv_out(self):
-		return self.walletconv_out('MMGen wallet','w',pw=True)
-
-	def ref_mn_conv_out(self):
-		return self.walletconv_out('MMGen native mnemonic data','mn')
-
-	def ref_bip39_conv_out(self):
-		return self.walletconv_out('BIP39 mnemonic data','bip39')
-
-	def ref_seed_conv_out(self):
-		return self.walletconv_out('seed data','seed')
-
-	def ref_hex_conv_out(self):
-		return self.walletconv_out('hexadecimal seed data with checksum','hexseed')
-
-	def ref_plainhex_conv_out(self):
-		return self.walletconv_out('plain hexadecimal seed data','hex')
-
-	def ref_incog_conv_out(self):
-		return self.walletconv_out('incognito data',out_fmt='i',pw=True)
-
-	def ref_incox_conv_out(self):
-		return self.walletconv_out('hex incognito data',out_fmt='xi',pw=True)
+	def ref_wallet_conv_out(self):   return self.walletconv_out('w')
+	def ref_mn_conv_out(self):       return self.walletconv_out('mn')
+	def ref_bip39_conv_out(self):    return self.walletconv_out('bip39')
+	def ref_seed_conv_out(self):     return self.walletconv_out('seed')
+	def ref_hex_conv_out(self):      return self.walletconv_out('hexseed')
+	def ref_plainhex_conv_out(self): return self.walletconv_out('hex')
+	def ref_incog_conv_out(self):    return self.walletconv_out('i')
+	def ref_incox_conv_out(self):    return self.walletconv_out('xi')
 
 	def ref_hincog_conv_out(self,ic_f=None):
-		if not ic_f: ic_f = joinpath(self.tmpdir,hincog_fn)
+		if not ic_f:
+			ic_f = joinpath(self.tmpdir,hincog_fn)
 		hi_parms = '{},{}'.format(ic_f,ref_wallet_incog_offset)
 		sl_parm = '-l' + str(self.seed_len)
-		return self.walletconv_out( 'hidden incognito data','hi',
+		return self.walletconv_out('hi',
 									uopts     = ['-J',hi_parms,sl_parm],
-									uopts_chk = ['-H',hi_parms,sl_parm],
-									pw        = True )
+									uopts_chk = ['-H',hi_parms,sl_parm] )
 
 	def ref_hincog_blkdev_conv_out(self):
 		def do_run(cmd):
@@ -185,58 +164,61 @@ class TestSuiteWalletConv(TestSuiteBase,TestSuiteShared):
 		return 'ok'
 
 	# wallet conversion tests
-	def walletconv_in(self,infile,desc,uopts=[],pw=False,oo=False):
-		opts = ['-d',self.tmpdir,'-o','words',self.usr_rand_arg]
+	def walletconv_in(self,infile,uopts=[],oo=False,icls=None):
+		ocls = MMGenMnemonic
+		opts = ['-d',self.tmpdir,'-o',ocls.fmt_codes[0],self.usr_rand_arg]
 		if_arg = [infile] if infile else []
 		d = '(convert)'
 		t = self.spawn('mmgen-walletconv',opts+uopts+if_arg,extra_desc=d)
 		t.license()
-		if desc == 'brainwallet':
+		icls = icls or SeedSource.ext_to_type(get_extension(infile))
+		if icls == Brainwallet:
 			t.expect('Enter brainwallet: ',ref_wallet_brainpass+'\n')
+		pw = issubclass(icls,SeedSourceEnc) and icls != Brainwallet
 		if pw:
-			t.passphrase(desc,self.wpasswd)
+			t.passphrase(icls.desc,self.wpasswd)
 			if self.test_name[:19] == 'ref_hincog_conv_old':
 				t.expect('Is the Seed ID correct? (Y/n): ','\n')
 			else:
 				t.expect(['Passphrase is OK',' are correct'])
-		# Output
-		wf = t.written_to_file('MMGen native mnemonic data',oo=oo)
+		wf = t.written_to_file(capfirst(ocls.desc),oo=oo)
 		t.p.wait()
 		# back check of result
 		msg('' if opt.profile else ' OK')
 		return self.walletchk(  wf,
 								pf         = None,
 								extra_desc = '(check)',
-								desc       = 'MMGen native mnemonic data',
 								sid        = self.seed_id )
 
-	def walletconv_out(self,desc,out_fmt='w',uopts=[],uopts_chk=[],pw=False):
+	def walletconv_out(self,out_fmt='w',uopts=[],uopts_chk=[]):
+		wcls = SeedSource.fmt_code_to_type(out_fmt)
 		opts = ['-d',self.tmpdir,'-p1','-o',out_fmt] + uopts
 		infile = joinpath(ref_dir,self.seed_id+'.mmwords')
 		t = self.spawn('mmgen-walletconv',[self.usr_rand_arg]+opts+[infile],extra_desc='(convert)')
 
 		add_args = ['-l{}'.format(self.seed_len)]
 		t.license()
+		pw = issubclass(wcls,SeedSourceEnc) and wcls != Brainwallet
 		if pw:
-			t.passphrase_new('new '+desc,self.wpasswd)
+			t.passphrase_new('new '+wcls.desc,self.wpasswd)
 			t.usr_rand(self.usr_rand_chars)
-		if ' '.join(desc.split()[-2:]) == 'incognito data':
+		if wcls in (IncogWallet,IncogWalletHex,IncogWalletHidden):
 			for i in (1,2,3):
 				t.expect('Generating encryption key from OS random data ')
-		if desc == 'hidden incognito data':
+		if wcls == IncogWalletHidden:
 			t.hincog_create(hincog_bytes)
-		if out_fmt == 'w': t.label()
-		wf = t.written_to_file(capfirst(desc),oo=True)
+		if out_fmt == 'w':
+			t.label()
+		wf = t.written_to_file(capfirst(wcls.desc),oo=True)
 		pf = None
 
-		if desc == 'hidden incognito data':
+		if wcls == IncogWalletHidden:
 			add_args += uopts_chk
 			wf = None
 		msg('' if opt.profile else ' OK')
 		return self.walletchk(  wf,
 								pf         = pf,
-								pw         = pw,
-								desc       = desc,
+								wcls       = wcls,
 								extra_desc = '(check)',
 								sid        = self.seed_id,
 								add_args   = add_args )