tool.py 37 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128
  1. #!/usr/bin/env python3
  2. #
  3. # mmgen = Multi-Mode GENerator, command-line Bitcoin cold storage solution
  4. # Copyright (C)2013-2022 The MMGen Project <mmgen@tuta.io>
  5. #
  6. # This program is free software: you can redistribute it and/or modify
  7. # it under the terms of the GNU General Public License as published by
  8. # the Free Software Foundation, either version 3 of the License, or
  9. # (at your option) any later version.
  10. #
  11. # This program is distributed in the hope that it will be useful,
  12. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. # GNU General Public License for more details.
  15. #
  16. # You should have received a copy of the GNU General Public License
  17. # along with this program. If not, see <http://www.gnu.org/licenses/>.
  18. """
  19. tool.py: Routines for the 'mmgen-tool' utility
  20. """
  21. from .protocol import hash160
  22. from .common import *
  23. from .crypto import *
  24. from .addr import *
  25. NL = ('\n','\r\n')[g.platform=='win']
  26. def _options_annot_str(l):
  27. return "(valid options: '{}')".format( "','".join(l) )
  28. def _create_argtuple(method,localvars):
  29. co = method.__code__
  30. args = co.co_varnames[1:co.co_argcount]
  31. return namedtuple('cmd_args',args)(*(localvars[a] for a in args))
  32. def _create_call_sig(cmd,parsed=False):
  33. m = MMGenToolCmds[cmd]
  34. if 'varargs_call_sig' in m.__code__.co_varnames: # hack
  35. flag = 'VAR_ARGS'
  36. va = m.__defaults__[0]
  37. args,dfls,ann = va['args'],va['dfls'],va['annots']
  38. else:
  39. flag = None
  40. args = m.__code__.co_varnames[1:m.__code__.co_argcount]
  41. dfls = m.__defaults__ or ()
  42. ann = m.__annotations__
  43. nargs = len(args) - len(dfls)
  44. def get_type_from_ann(arg):
  45. return ann[arg][1:] + (' or STDIN','')[parsed] if ann[arg] == 'sstr' else ann[arg].__name__
  46. if parsed:
  47. c_args = [(a,get_type_from_ann(a)) for a in args[:nargs]]
  48. c_kwargs = [(a,dfls[n]) for n,a in enumerate(args[nargs:])]
  49. return c_args,dict(c_kwargs),'STDIN_OK' if c_args and ann[args[0]] == 'sstr' else flag
  50. else:
  51. c_args = [f'{a} [{get_type_from_ann(a)}]' for a in args[:nargs]]
  52. c_kwargs = ['"{}" [{}={!r}{}]'.format(
  53. a,
  54. type(dfls[n]).__name__, dfls[n],
  55. (' ' + ann[a] if a in ann else '') )
  56. for n,a in enumerate(args[nargs:])]
  57. return ' '.join(c_args + c_kwargs)
  58. def _usage(cmd=None,exit_val=1):
  59. m1=('USAGE INFORMATION FOR MMGEN-TOOL COMMANDS:\n\n'
  60. ' Unquoted arguments are mandatory\n'
  61. ' Quoted arguments are optional, default values will be used\n'
  62. ' Argument types and default values are shown in square brackets\n')
  63. m2=(' To force a command to read from STDIN instead of file (for commands taking\n'
  64. ' a filename as their first argument), substitute "-" for the filename.\n\n'
  65. 'EXAMPLES:\n\n'
  66. ' Generate a random Bech32 public/private keypair for LTC:\n'
  67. ' $ mmgen-tool -r0 --coin=ltc --type=bech32 randpair\n\n'
  68. ' Generate a DASH compressed public key address from the supplied WIF key:\n'
  69. ' $ mmgen-tool --coin=dash --type=compressed wif2addr XJkVRC3eGKurc9Uzx1wfQoio3yqkmaXVqLMTa6y7s3M3jTBnmxfw\n\n'
  70. ' Generate a well-known burn address:\n'
  71. ' $ mmgen-tool hextob58chk 000000000000000000000000000000000000000000\n\n'
  72. ' Generate a random 12-word seed phrase:\n'
  73. ' $ mmgen-tool -r0 mn_rand128\n\n'
  74. ' Same as above, but get additional entropy from user:\n'
  75. ' $ mmgen-tool mn_rand128\n\n'
  76. ' Encode bytes from a file to base 58:\n'
  77. ' $ mmgen-tool bytestob58 /etc/timezone pad=20\n\n'
  78. ' Reverse a hex string:\n'
  79. ' $ mmgen-tool hexreverse "deadbeefcafe"\n\n'
  80. ' Same as above, but use a pipe:\n'
  81. ' $ echo "deadbeefcafe" | mmgen-tool hexreverse -')
  82. if not cmd:
  83. Msg(m1)
  84. for bc in MMGenToolCmds.classes.values():
  85. cls_info = bc.__doc__.strip().split('\n')[0]
  86. Msg(' {}{}\n'.format(cls_info[0].upper(),cls_info[1:]))
  87. max_w = max(map(len,bc.user_commands))
  88. for cmd in sorted(bc.user_commands):
  89. Msg(f' {cmd:{max_w}} {_create_call_sig(cmd)}')
  90. Msg('')
  91. Msg(m2)
  92. elif cmd in MMGenToolCmds:
  93. p1 = fmt(capfirst(MMGenToolCmds[cmd].__doc__.strip()),strip_char='\t').strip()
  94. msg('{}{}\nUSAGE: {} {} {}'.format(
  95. p1,
  96. ('\n' if '\n' in p1 else ''),
  97. g.prog_name,cmd,
  98. _create_call_sig(cmd))
  99. )
  100. else:
  101. die(1,f'{cmd!r}: no such tool command')
  102. sys.exit(exit_val)
  103. def _process_args(cmd,cmd_args):
  104. c_args,c_kwargs,flag = _create_call_sig(cmd,parsed=True)
  105. have_stdin_input = False
  106. if flag != 'VAR_ARGS':
  107. if len(cmd_args) < len(c_args):
  108. msg(f'Command requires exactly {len(c_args)} non-keyword argument{suf(c_args)}')
  109. _usage(cmd)
  110. u_args = cmd_args[:len(c_args)]
  111. # If we're reading from a pipe, replace '-' with output of previous command
  112. if flag == 'STDIN_OK' and u_args and u_args[0] == '-':
  113. if sys.stdin.isatty():
  114. raise BadFilename("Standard input is a TTY. Can't use '-' as a filename")
  115. else:
  116. max_dlen_spec = '10kB' # limit input to 10KB for now
  117. max_dlen = MMGenToolCmdUtil().bytespec(max_dlen_spec)
  118. u_args[0] = os.read(0,max_dlen)
  119. have_stdin_input = True
  120. if len(u_args[0]) >= max_dlen:
  121. die(2,f'Maximum data input for this command is {max_dlen_spec}')
  122. if not u_args[0]:
  123. die(2,f'{cmd}: ERROR: no output from previous command in pipe')
  124. u_nkwargs = len(cmd_args) - len(c_args)
  125. u_kwargs = {}
  126. if flag == 'VAR_ARGS':
  127. t = [a.split('=',1) for a in cmd_args if '=' in a]
  128. tk = [a[0] for a in t]
  129. tk_bad = [a for a in tk if a not in c_kwargs]
  130. if set(tk_bad) != set(tk[:len(tk_bad)]): # permit non-kw args to contain '='
  131. die(1,f'{tk_bad[-1]!r}: illegal keyword argument')
  132. u_kwargs = dict(t[len(tk_bad):])
  133. u_args = cmd_args[:-len(u_kwargs) or None]
  134. elif u_nkwargs > 0:
  135. u_kwargs = dict([a.split('=',1) for a in cmd_args[len(c_args):] if '=' in a])
  136. if len(u_kwargs) != u_nkwargs:
  137. msg(f'Command requires exactly {len(c_args)} non-keyword argument{suf(c_args)}')
  138. _usage(cmd)
  139. if len(u_kwargs) > len(c_kwargs):
  140. msg(f'Command accepts no more than {len(c_kwargs)} keyword argument{suf(c_kwargs)}')
  141. _usage(cmd)
  142. for k in u_kwargs:
  143. if k not in c_kwargs:
  144. msg(f'{k!r}: invalid keyword argument')
  145. _usage(cmd)
  146. def conv_type(arg,arg_name,arg_type):
  147. if arg_type == 'bytes' and type(arg) != bytes:
  148. die(1,"'Binary input data must be supplied via STDIN")
  149. if have_stdin_input and arg_type == 'str' and isinstance(arg,bytes):
  150. arg = arg.decode()
  151. if arg[-len(NL):] == NL: # rstrip one newline
  152. arg = arg[:-len(NL)]
  153. if arg_type == 'bool':
  154. if arg.lower() in ('true','yes','1','on'): arg = True
  155. elif arg.lower() in ('false','no','0','off'): arg = False
  156. else:
  157. msg(f'{arg!r}: invalid boolean value for keyword argument')
  158. _usage(cmd)
  159. try:
  160. return __builtins__[arg_type](arg)
  161. except:
  162. die(1,f'{arg!r}: Invalid argument for argument {arg_name} ({arg_type!r} required)')
  163. if flag == 'VAR_ARGS':
  164. args = [conv_type(u_args[i],c_args[0][0],c_args[0][1]) for i in range(len(u_args))]
  165. else:
  166. args = [conv_type(u_args[i],c_args[i][0],c_args[i][1]) for i in range(len(c_args))]
  167. kwargs = {k:conv_type(u_kwargs[k],k,type(c_kwargs[k]).__name__) for k in u_kwargs}
  168. return args,kwargs
  169. def _process_result(ret,pager=False,print_result=False):
  170. """
  171. Convert result to something suitable for output to screen and return it.
  172. If result is bytes and not convertible to utf8, output as binary using os.write().
  173. If 'print_result' is True, send the converted result directly to screen or
  174. pager instead of returning it.
  175. """
  176. def triage_result(o):
  177. return o if not print_result else do_pager(o) if pager else Msg(o)
  178. if ret == True:
  179. return True
  180. elif ret in (False,None):
  181. ydie(1,f'tool command returned {ret!r}')
  182. elif isinstance(ret,str):
  183. return triage_result(ret)
  184. elif isinstance(ret,int):
  185. return triage_result(str(ret))
  186. elif isinstance(ret,tuple):
  187. return triage_result('\n'.join([r.decode() if isinstance(r,bytes) else r for r in ret]))
  188. elif isinstance(ret,bytes):
  189. try:
  190. o = ret.decode()
  191. return o if not print_result else do_pager(o) if pager else Msg(o)
  192. except:
  193. # don't add NL to binary data if it can't be converted to utf8
  194. return ret if not print_result else os.write(1,ret)
  195. else:
  196. ydie(1,f'tool.py: can’t handle return value of type {type(ret).__name__!r}')
  197. from .obj import MMGenAddrType
  198. def conv_cls_bip39():
  199. from .bip39 import bip39
  200. return bip39
  201. dfl_mnemonic_fmt = 'mmgen'
  202. mnemonic_fmts = {
  203. 'mmgen': { 'fmt': 'words', 'conv_cls': lambda: baseconv },
  204. 'bip39': { 'fmt': 'bip39', 'conv_cls': conv_cls_bip39 },
  205. 'xmrseed': { 'fmt': 'xmrseed','conv_cls': lambda: baseconv },
  206. }
  207. mn_opts_disp = _options_annot_str(mnemonic_fmts)
  208. class MMGenToolCmdMeta(type):
  209. classes = {}
  210. methods = {}
  211. def __new__(mcls,name,bases,namespace):
  212. methods = {k:v for k,v in namespace.items() if k[0] != '_' and callable(v) and v.__doc__}
  213. if g.test_suite:
  214. if name in mcls.classes:
  215. raise ValueError(f'Class {name!r} already defined!')
  216. for m in methods:
  217. if m in mcls.methods:
  218. raise ValueError(f'Method {m!r} already defined!')
  219. if not getattr(m,'__doc__',None):
  220. raise ValueError(f'Method {m!r} has no doc string!')
  221. cls = super().__new__(mcls,name,bases,namespace)
  222. if bases and name != 'tool_api':
  223. mcls.classes[name] = cls
  224. mcls.methods.update(methods)
  225. return cls
  226. def __iter__(cls):
  227. return cls.methods.__iter__()
  228. def __getitem__(cls,val):
  229. return cls.methods.__getitem__(val)
  230. def __contains__(cls,val):
  231. return cls.methods.__contains__(val)
  232. def classname(cls,cmd_name):
  233. return cls.methods[cmd_name].__qualname__.split('.')[0]
  234. def call(cls,cmd_name,*args,**kwargs):
  235. return getattr(cls.classes[cls.classname(cmd_name)](),cmd_name)(*args,**kwargs)
  236. @property
  237. def user_commands(cls):
  238. return {k:v for k,v in cls.__dict__.items() if k in cls.methods}
  239. class MMGenToolCmds(metaclass=MMGenToolCmdMeta):
  240. def __init__(self,proto=None,mmtype=None):
  241. from .protocol import init_proto_from_opts
  242. self.proto = proto or init_proto_from_opts()
  243. self.mmtype = MMGenAddrType(self.proto,(mmtype or getattr(opt,'type',None) or self.proto.dfl_mmtype))
  244. if g.token:
  245. self.proto.tokensym = g.token.upper()
  246. def init_generators(self,arg=None):
  247. gd = namedtuple('generator_data',['at','kg','ag'])
  248. at = MMGenAddrType(
  249. proto = self.proto,
  250. id_str = self.mmtype )
  251. if arg == 'addrtype_only':
  252. return gd(at,None,None)
  253. else:
  254. return gd(
  255. at,
  256. KeyGenerator(self.proto,at),
  257. AddrGenerator(self.proto,at),
  258. )
  259. class MMGenToolCmdMisc(MMGenToolCmds):
  260. "miscellaneous commands"
  261. def help(self,command_name=''):
  262. "display usage information for a single command or all commands"
  263. _usage(command_name,exit_val=0)
  264. usage = help
  265. class MMGenToolCmdUtil(MMGenToolCmds):
  266. "general string conversion and hashing utilities"
  267. def bytespec(self,dd_style_byte_specifier:str):
  268. "convert a byte specifier such as '1GB' into an integer"
  269. return parse_bytespec(dd_style_byte_specifier)
  270. def to_bytespec(self,
  271. n: int,
  272. dd_style_byte_specifier: str,
  273. fmt = '0.2',
  274. print_sym = True ):
  275. "convert an integer to a byte specifier such as '1GB'"
  276. return int2bytespec(n,dd_style_byte_specifier,fmt,print_sym)
  277. def randhex(self,nbytes='32'):
  278. "print 'n' bytes (default 32) of random data in hex format"
  279. return get_random(int(nbytes)).hex()
  280. def hexreverse(self,hexstr:'sstr'):
  281. "reverse bytes of a hexadecimal string"
  282. return bytes.fromhex(hexstr.strip())[::-1].hex()
  283. def hexlify(self,infile:str):
  284. "convert bytes in file to hexadecimal (use '-' for stdin)"
  285. data = get_data_from_file(infile,dash=True,quiet=True,binary=True)
  286. return data.hex()
  287. def unhexlify(self,hexstr:'sstr'):
  288. "convert hexadecimal value to bytes (warning: outputs binary data)"
  289. return bytes.fromhex(hexstr)
  290. def hexdump(self,infile:str,cols=8,line_nums='hex'):
  291. "create hexdump of data from file (use '-' for stdin)"
  292. data = get_data_from_file(infile,dash=True,quiet=True,binary=True)
  293. return pretty_hexdump(data,cols=cols,line_nums=line_nums).rstrip()
  294. def unhexdump(self,infile:str):
  295. "decode hexdump from file (use '-' for stdin) (warning: outputs binary data)"
  296. if g.platform == 'win':
  297. import msvcrt
  298. msvcrt.setmode(sys.stdout.fileno(),os.O_BINARY)
  299. hexdata = get_data_from_file(infile,dash=True,quiet=True)
  300. return decode_pretty_hexdump(hexdata)
  301. def hash160(self,hexstr:'sstr'):
  302. "compute ripemd160(sha256(data)) (convert hex pubkey to hex addr)"
  303. return hash160(hexstr)
  304. def hash256(self,string_or_bytes:str,file_input=False,hex_input=False): # TODO: handle stdin
  305. "compute sha256(sha256(data)) (double sha256)"
  306. from hashlib import sha256
  307. if file_input: b = get_data_from_file(string_or_bytes,binary=True)
  308. elif hex_input: b = decode_pretty_hexdump(string_or_bytes)
  309. else: b = string_or_bytes
  310. return sha256(sha256(b.encode()).digest()).hexdigest()
  311. def id6(self,infile:str):
  312. "generate 6-character MMGen ID for a file (use '-' for stdin)"
  313. return make_chksum_6(
  314. get_data_from_file(infile,dash=True,quiet=True,binary=True))
  315. def str2id6(self,string:'sstr'): # retain ignoring of space for backwards compat
  316. "generate 6-character MMGen ID for a string, ignoring spaces"
  317. return make_chksum_6(''.join(string.split()))
  318. def id8(self,infile:str):
  319. "generate 8-character MMGen ID for a file (use '-' for stdin)"
  320. return make_chksum_8(
  321. get_data_from_file(infile,dash=True,quiet=True,binary=True))
  322. def randb58(self,nbytes=32,pad=0):
  323. "generate random data (default: 32 bytes) and convert it to base 58"
  324. return baseconv.frombytes(get_random(nbytes),'b58',pad=pad,tostr=True)
  325. def bytestob58(self,infile:str,pad=0):
  326. "convert bytes to base 58 (supply data via STDIN)"
  327. data = get_data_from_file(infile,dash=True,quiet=True,binary=True)
  328. return baseconv.frombytes(data,'b58',pad=pad,tostr=True)
  329. def b58tobytes(self,b58num:'sstr',pad=0):
  330. "convert a base 58 number to bytes (warning: outputs binary data)"
  331. return baseconv.tobytes(b58num,'b58',pad=pad)
  332. def hextob58(self,hexstr:'sstr',pad=0):
  333. "convert a hexadecimal number to base 58"
  334. return baseconv.fromhex(hexstr,'b58',pad=pad,tostr=True)
  335. def b58tohex(self,b58num:'sstr',pad=0):
  336. "convert a base 58 number to hexadecimal"
  337. return baseconv.tohex(b58num,'b58',pad=pad)
  338. def hextob58chk(self,hexstr:'sstr'):
  339. "convert a hexadecimal number to base58-check encoding"
  340. from .protocol import _b58chk_encode
  341. return _b58chk_encode(bytes.fromhex(hexstr))
  342. def b58chktohex(self,b58chk_num:'sstr'):
  343. "convert a base58-check encoded number to hexadecimal"
  344. from .protocol import _b58chk_decode
  345. return _b58chk_decode(b58chk_num).hex()
  346. def hextob32(self,hexstr:'sstr',pad=0):
  347. "convert a hexadecimal number to MMGen's flavor of base 32"
  348. return baseconv.fromhex(hexstr,'b32',pad,tostr=True)
  349. def b32tohex(self,b32num:'sstr',pad=0):
  350. "convert an MMGen-flavor base 32 number to hexadecimal"
  351. return baseconv.tohex(b32num.upper(),'b32',pad)
  352. def hextob6d(self,hexstr:'sstr',pad=0,add_spaces=True):
  353. "convert a hexadecimal number to die roll base6 (base6d)"
  354. ret = baseconv.fromhex(hexstr,'b6d',pad,tostr=True)
  355. return block_format(ret,gw=5,cols=None).strip() if add_spaces else ret
  356. def b6dtohex(self,b6d_num:'sstr',pad=0):
  357. "convert a die roll base6 (base6d) number to hexadecimal"
  358. return baseconv.tohex(remove_whitespace(b6d_num),'b6d',pad)
  359. class MMGenToolCmdCoin(MMGenToolCmds):
  360. """
  361. cryptocoin key/address utilities
  362. May require use of the '--coin', '--type' and/or '--testnet' options
  363. Examples:
  364. mmgen-tool --coin=ltc --type=bech32 wif2addr <wif key>
  365. mmgen-tool --coin=zec --type=zcash_z randpair
  366. """
  367. def randwif(self):
  368. "generate a random private key in WIF format"
  369. gd = self.init_generators('addrtype_only')
  370. return PrivKey(
  371. self.proto,
  372. get_random(32),
  373. pubkey_type = gd.at.pubkey_type,
  374. compressed = gd.at.compressed ).wif
  375. def randpair(self):
  376. "generate a random private key/address pair"
  377. gd = self.init_generators()
  378. privhex = PrivKey(
  379. self.proto,
  380. get_random(32),
  381. pubkey_type = gd.at.pubkey_type,
  382. compressed = gd.at.compressed )
  383. addr = gd.ag.to_addr(gd.kg.to_pubhex(privhex))
  384. return (privhex.wif,addr)
  385. def wif2hex(self,wifkey:'sstr'):
  386. "convert a private key from WIF to hex format"
  387. return PrivKey(
  388. self.proto,
  389. wif = wifkey )
  390. def hex2wif(self,privhex:'sstr'):
  391. "convert a private key from hex to WIF format"
  392. gd = self.init_generators('addrtype_only')
  393. return PrivKey(
  394. self.proto,
  395. bytes.fromhex(privhex),
  396. pubkey_type = gd.at.pubkey_type,
  397. compressed = gd.at.compressed ).wif
  398. def wif2addr(self,wifkey:'sstr'):
  399. "generate a coin address from a key in WIF format"
  400. gd = self.init_generators()
  401. privhex = PrivKey(
  402. self.proto,
  403. wif = wifkey )
  404. addr = gd.ag.to_addr(gd.kg.to_pubhex(privhex))
  405. return addr
  406. def wif2redeem_script(self,wifkey:'sstr'): # new
  407. "convert a WIF private key to a Segwit P2SH-P2WPKH redeem script"
  408. assert self.mmtype.name == 'segwit','This command is meaningful only for --type=segwit'
  409. gd = self.init_generators()
  410. privhex = PrivKey(
  411. self.proto,
  412. wif = wifkey )
  413. return gd.ag.to_segwit_redeem_script(gd.kg.to_pubhex(privhex))
  414. def wif2segwit_pair(self,wifkey:'sstr'):
  415. "generate both a Segwit P2SH-P2WPKH redeem script and address from WIF"
  416. assert self.mmtype.name == 'segwit','This command is meaningful only for --type=segwit'
  417. gd = self.init_generators()
  418. pubhex = gd.kg.to_pubhex(PrivKey(
  419. self.proto,
  420. wif = wifkey ))
  421. addr = gd.ag.to_addr(pubhex)
  422. rs = gd.ag.to_segwit_redeem_script(pubhex)
  423. return (rs,addr)
  424. def privhex2addr(self,privhex:'sstr',output_pubhex=False):
  425. "generate coin address from raw private key data in hexadecimal format"
  426. gd = self.init_generators()
  427. pk = PrivKey(
  428. self.proto,
  429. bytes.fromhex(privhex),
  430. compressed = gd.at.compressed,
  431. pubkey_type = gd.at.pubkey_type )
  432. ph = gd.kg.to_pubhex(pk)
  433. return ph if output_pubhex else gd.ag.to_addr(ph)
  434. def privhex2pubhex(self,privhex:'sstr'): # new
  435. "generate a hex public key from a hex private key"
  436. return self.privhex2addr(privhex,output_pubhex=True)
  437. def pubhex2addr(self,pubkeyhex:'sstr'):
  438. "convert a hex pubkey to an address"
  439. if self.mmtype.name == 'segwit':
  440. return self.proto.pubhex2segwitaddr(pubkeyhex)
  441. else:
  442. return self.pubhash2addr(hash160(pubkeyhex))
  443. def pubhex2redeem_script(self,pubkeyhex:'sstr'): # new
  444. "convert a hex pubkey to a Segwit P2SH-P2WPKH redeem script"
  445. assert self.mmtype.name == 'segwit','This command is meaningful only for --type=segwit'
  446. return self.proto.pubhex2redeem_script(pubkeyhex)
  447. def redeem_script2addr(self,redeem_scripthex:'sstr'): # new
  448. "convert a Segwit P2SH-P2WPKH redeem script to an address"
  449. assert self.mmtype.name == 'segwit', 'This command is meaningful only for --type=segwit'
  450. assert redeem_scripthex[:4] == '0014', f'{redeem_scripthex!r}: invalid redeem script'
  451. assert len(redeem_scripthex) == 44, f'{len(redeem_scripthex)//2} bytes: invalid redeem script length'
  452. return self.pubhash2addr(hash160(redeem_scripthex))
  453. def pubhash2addr(self,pubhashhex:'sstr'):
  454. "convert public key hash to address"
  455. if self.mmtype.name == 'bech32':
  456. return self.proto.pubhash2bech32addr(pubhashhex)
  457. else:
  458. gd = self.init_generators('addrtype_only')
  459. return self.proto.pubhash2addr(pubhashhex,gd.at.addr_fmt=='p2sh')
  460. def addr2pubhash(self,addr:'sstr'):
  461. "convert coin address to public key hash"
  462. from .tx import addr2pubhash
  463. return addr2pubhash(self.proto,CoinAddr(self.proto,addr))
  464. def addr2scriptpubkey(self,addr:'sstr'):
  465. "convert coin address to scriptPubKey"
  466. from .tx import addr2scriptPubKey
  467. return addr2scriptPubKey(self.proto,CoinAddr(self.proto,addr))
  468. def scriptpubkey2addr(self,hexstr:'sstr'):
  469. "convert scriptPubKey to coin address"
  470. from .tx import scriptPubKey2addr
  471. return scriptPubKey2addr(self.proto,hexstr)[0]
  472. class MMGenToolCmdMnemonic(MMGenToolCmds):
  473. """
  474. seed phrase utilities (valid formats: 'mmgen' (default), 'bip39', 'xmrseed')
  475. IMPORTANT NOTE: MMGen's default seed phrase format uses the Electrum
  476. wordlist, however seed phrases are computed using a different algorithm
  477. and are NOT Electrum-compatible!
  478. BIP39 support is fully compatible with the standard, allowing users to
  479. import and export seed entropy from BIP39-compatible wallets. However,
  480. users should be aware that BIP39 support does not imply BIP32 support!
  481. MMGen uses its own key derivation scheme differing from the one described
  482. by the BIP32 protocol.
  483. For Monero ('xmrseed') seed phrases, input data is reduced to a spendkey
  484. before conversion so that a canonical seed phrase is produced. This is
  485. required because Monero seeds, unlike ordinary wallet seeds, are tied
  486. to a concrete key/address pair. To manually generate a Monero spendkey,
  487. use the 'hex2wif' command.
  488. """
  489. @staticmethod
  490. def _xmr_reduce(bytestr):
  491. from .protocol import init_proto
  492. proto = init_proto('xmr')
  493. if len(bytestr) != proto.privkey_len:
  494. die(1,'{!r}: invalid bit length for Monero private key (must be {})'.format(
  495. len(bytestr*8),
  496. proto.privkey_len*8 ))
  497. return proto.preprocess_key(bytestr,None)
  498. def _do_random_mn(self,nbytes:int,fmt:str):
  499. assert nbytes in (16,24,32), 'nbytes must be 16, 24 or 32'
  500. randbytes = get_random(nbytes)
  501. if fmt == 'xmrseed':
  502. randbytes = self._xmr_reduce(randbytes)
  503. if opt.verbose:
  504. msg(f'Seed: {randbytes.hex()}')
  505. return self.hex2mn(randbytes.hex(),fmt=fmt)
  506. def mn_rand128(self, fmt:mn_opts_disp = dfl_mnemonic_fmt ):
  507. "generate random 128-bit mnemonic seed phrase"
  508. return self._do_random_mn(16,fmt)
  509. def mn_rand192(self, fmt:mn_opts_disp = dfl_mnemonic_fmt ):
  510. "generate random 192-bit mnemonic seed phrase"
  511. return self._do_random_mn(24,fmt)
  512. def mn_rand256(self, fmt:mn_opts_disp = dfl_mnemonic_fmt ):
  513. "generate random 256-bit mnemonic seed phrase"
  514. return self._do_random_mn(32,fmt)
  515. def hex2mn( self, hexstr:'sstr', fmt:mn_opts_disp = dfl_mnemonic_fmt ):
  516. "convert a 16, 24 or 32-byte hexadecimal number to a mnemonic seed phrase"
  517. if fmt == 'bip39':
  518. from .bip39 import bip39
  519. return ' '.join(bip39.fromhex(hexstr,fmt))
  520. else:
  521. bytestr = bytes.fromhex(hexstr)
  522. if fmt == 'xmrseed':
  523. bytestr = self._xmr_reduce(bytestr)
  524. return baseconv.frombytes(bytestr,fmt,'seed',tostr=True)
  525. def mn2hex( self, seed_mnemonic:'sstr', fmt:mn_opts_disp = dfl_mnemonic_fmt ):
  526. "convert a mnemonic seed phrase to a hexadecimal number"
  527. if fmt == 'bip39':
  528. from .bip39 import bip39
  529. return bip39.tohex(seed_mnemonic.split(),fmt)
  530. else:
  531. return baseconv.tohex(seed_mnemonic.split(),fmt,'seed')
  532. def mn2hex_interactive( self, fmt:mn_opts_disp = dfl_mnemonic_fmt, mn_len=24, print_mn=False ):
  533. "convert an interactively supplied mnemonic seed phrase to a hexadecimal number"
  534. from .mn_entry import mn_entry
  535. mn = mn_entry(fmt).get_mnemonic_from_user(25 if fmt == 'xmrseed' else mn_len,validate=False)
  536. if print_mn:
  537. msg(mn)
  538. return self.mn2hex(seed_mnemonic=mn,fmt=fmt)
  539. def mn_stats(self, fmt:mn_opts_disp = dfl_mnemonic_fmt ):
  540. "show stats for mnemonic wordlist"
  541. conv_cls = mnemonic_fmts[fmt]['conv_cls']()
  542. return conv_cls.check_wordlist(fmt)
  543. def mn_printlist( self, fmt:mn_opts_disp = dfl_mnemonic_fmt, enum=False, pager=False ):
  544. "print mnemonic wordlist"
  545. conv_cls = mnemonic_fmts[fmt]['conv_cls']()
  546. ret = conv_cls.get_wordlist(fmt)
  547. if enum:
  548. ret = [f'{n:>4} {e}' for n,e in enumerate(ret)]
  549. return '\n'.join(ret)
  550. class MMGenToolCmdFile(MMGenToolCmds):
  551. "utilities for viewing/checking MMGen address and transaction files"
  552. def _file_chksum(self,mmgen_addrfile,objname):
  553. verbose,yes,quiet = [bool(i) for i in (opt.verbose,opt.yes,opt.quiet)]
  554. opt.verbose,opt.yes,opt.quiet = (False,True,True)
  555. ret = globals()[objname](self.proto,mmgen_addrfile)
  556. opt.verbose,opt.yes,opt.quiet = (verbose,yes,quiet)
  557. if verbose:
  558. if ret.al_id.mmtype.name == 'password':
  559. msg('Passwd fmt: {}\nPasswd len: {}\nID string: {}'.format(
  560. capfirst(ret.pw_info[ret.pw_fmt].desc),
  561. ret.pw_len,
  562. ret.pw_id_str ))
  563. else:
  564. msg(f'Base coin: {ret.base_coin} {capfirst(ret.network)}')
  565. msg(f'MMType: {capfirst(ret.al_id.mmtype.name)}')
  566. msg( f'List length: {len(ret.data)}')
  567. return ret.chksum
  568. def addrfile_chksum(self,mmgen_addrfile:str):
  569. "compute checksum for MMGen address file"
  570. return self._file_chksum(mmgen_addrfile,'AddrList')
  571. def keyaddrfile_chksum(self,mmgen_keyaddrfile:str):
  572. "compute checksum for MMGen key-address file"
  573. return self._file_chksum(mmgen_keyaddrfile,'KeyAddrList')
  574. def passwdfile_chksum(self,mmgen_passwdfile:str):
  575. "compute checksum for MMGen password file"
  576. return self._file_chksum(mmgen_passwdfile,'PasswordList')
  577. async def txview( varargs_call_sig = { # hack to allow for multiple filenames
  578. 'args': (
  579. 'mmgen_tx_file(s)',
  580. 'pager',
  581. 'terse',
  582. 'sort',
  583. 'filesort' ),
  584. 'dfls': ( False, False, 'addr', 'mtime' ),
  585. 'annots': {
  586. 'mmgen_tx_file(s)': str,
  587. 'sort': _options_annot_str(['addr','raw']),
  588. 'filesort': _options_annot_str(['mtime','ctime','atime']),
  589. } },
  590. *infiles,**kwargs):
  591. "show raw/signed MMGen transaction in human-readable form"
  592. terse = bool(kwargs.get('terse'))
  593. tx_sort = kwargs.get('sort') or 'addr'
  594. file_sort = kwargs.get('filesort') or 'mtime'
  595. from .filename import MMGenFileList
  596. from .tx import MMGenTX
  597. flist = MMGenFileList(infiles,ftype=MMGenTX)
  598. flist.sort_by_age(key=file_sort) # in-place sort
  599. async def process_file(fn):
  600. if fn.endswith(MMGenTX.Signed.ext):
  601. tx = MMGenTX.Signed(
  602. filename = fn,
  603. quiet_open = True,
  604. tw = await MMGenTX.Signed.get_tracking_wallet(fn) )
  605. else:
  606. tx = MMGenTX.Unsigned(
  607. filename = fn,
  608. quiet_open = True )
  609. return tx.format_view(terse=terse,sort=tx_sort)
  610. return ('—'*77+'\n').join([await process_file(fn) for fn in flist.names()]).rstrip()
  611. class MMGenToolCmdFileCrypt(MMGenToolCmds):
  612. """
  613. file encryption and decryption
  614. MMGen encryption suite:
  615. * Key: Scrypt (user-configurable hash parameters, 32-byte salt)
  616. * Enc: AES256_CTR, 16-byte rand IV, sha256 hash + 32-byte nonce + data
  617. * The encrypted file is indistinguishable from random data
  618. """
  619. def encrypt(self,infile:str,outfile='',hash_preset=''):
  620. "encrypt a file"
  621. data = get_data_from_file(infile,'data for encryption',binary=True)
  622. enc_d = mmgen_encrypt(data,'user data',hash_preset)
  623. if not outfile:
  624. outfile = f'{os.path.basename(infile)}.{g.mmenc_ext}'
  625. write_data_to_file(outfile,enc_d,'encrypted data',binary=True)
  626. return True
  627. def decrypt(self,infile:str,outfile='',hash_preset=''):
  628. "decrypt a file"
  629. enc_d = get_data_from_file(infile,'encrypted data',binary=True)
  630. while True:
  631. dec_d = mmgen_decrypt(enc_d,'user data',hash_preset)
  632. if dec_d: break
  633. msg('Trying again...')
  634. if not outfile:
  635. o = os.path.basename(infile)
  636. outfile = remove_extension(o,g.mmenc_ext)
  637. if outfile == o: outfile += '.dec'
  638. write_data_to_file(outfile,dec_d,'decrypted data',binary=True)
  639. return True
  640. class MMGenToolCmdFileUtil(MMGenToolCmds):
  641. "file utilities"
  642. def find_incog_data(self,filename:str,incog_id:str,keep_searching=False):
  643. "Use an Incog ID to find hidden incognito wallet data"
  644. ivsize,bsize,mod = g.aesctr_iv_len,4096,4096*8
  645. n,carry = 0,b' '*ivsize
  646. flgs = os.O_RDONLY|os.O_BINARY if g.platform == 'win' else os.O_RDONLY
  647. f = os.open(filename,flgs)
  648. for ch in incog_id:
  649. if ch not in '0123456789ABCDEF':
  650. die(2,f'{incog_id!r}: invalid Incog ID')
  651. while True:
  652. d = os.read(f,bsize)
  653. if not d: break
  654. d = carry + d
  655. for i in range(bsize):
  656. if sha256(d[i:i+ivsize]).hexdigest()[:8].upper() == incog_id:
  657. if n+i < ivsize:
  658. continue
  659. msg(f'\rIncog data for ID {incog_id} found at offset {n+i-ivsize}')
  660. if not keep_searching:
  661. sys.exit(0)
  662. carry = d[len(d)-ivsize:]
  663. n += bsize
  664. if not n % mod:
  665. msg_r(f'\rSearched: {n} bytes')
  666. msg('')
  667. os.close(f)
  668. return True
  669. def rand2file(self,outfile:str,nbytes:str,threads=4,silent=False):
  670. "write 'n' bytes of random data to specified file"
  671. from threading import Thread
  672. from queue import Queue
  673. from cryptography.hazmat.primitives.ciphers import Cipher,algorithms,modes
  674. from cryptography.hazmat.backends import default_backend
  675. def encrypt_worker(wid):
  676. ctr_init_val = os.urandom(g.aesctr_iv_len)
  677. c = Cipher(algorithms.AES(key),modes.CTR(ctr_init_val),backend=default_backend())
  678. encryptor = c.encryptor()
  679. while True:
  680. q2.put(encryptor.update(q1.get()))
  681. q1.task_done()
  682. def output_worker():
  683. while True:
  684. f.write(q2.get())
  685. q2.task_done()
  686. nbytes = parse_bytespec(nbytes)
  687. if opt.outdir:
  688. outfile = make_full_path(opt.outdir,outfile)
  689. f = open(outfile,'wb')
  690. key = get_random(32)
  691. q1,q2 = Queue(),Queue()
  692. for i in range(max(1,threads-2)):
  693. t = Thread(target=encrypt_worker,args=[i])
  694. t.daemon = True
  695. t.start()
  696. t = Thread(target=output_worker)
  697. t.daemon = True
  698. t.start()
  699. blk_size = 1024 * 1024
  700. for i in range(nbytes // blk_size):
  701. if not i % 4:
  702. msg_r(f'\rRead: {i * blk_size} bytes')
  703. q1.put(os.urandom(blk_size))
  704. if nbytes % blk_size:
  705. q1.put(os.urandom(nbytes % blk_size))
  706. q1.join()
  707. q2.join()
  708. f.close()
  709. fsize = os.stat(outfile).st_size
  710. if fsize != nbytes:
  711. die(3,f'{fsize}: incorrect random file size (should be {nbytes})')
  712. if not silent:
  713. msg(f'\rRead: {nbytes} bytes')
  714. qmsg(f'\r{nbytes} byte{suf(nbytes)} of random data written to file {outfile!r}')
  715. return True
  716. class MMGenToolCmdWallet(MMGenToolCmds):
  717. "key, address or subseed generation from an MMGen wallet"
  718. def get_subseed(self,subseed_idx:str,wallet=''):
  719. "get the Seed ID of a single subseed by Subseed Index for default or specified wallet"
  720. opt.quiet = True
  721. sf = get_seed_file([wallet] if wallet else [],1)
  722. from .wallet import Wallet
  723. return Wallet(sf).seed.subseed(subseed_idx).sid
  724. def get_subseed_by_seed_id(self,seed_id:str,wallet='',last_idx=g.subseeds):
  725. "get the Subseed Index of a single subseed by Seed ID for default or specified wallet"
  726. opt.quiet = True
  727. sf = get_seed_file([wallet] if wallet else [],1)
  728. from .wallet import Wallet
  729. ret = Wallet(sf).seed.subseed_by_seed_id(seed_id,last_idx)
  730. return ret.ss_idx if ret else None
  731. def list_subseeds(self,subseed_idx_range:str,wallet=''):
  732. "list a range of subseed Seed IDs for default or specified wallet"
  733. opt.quiet = True
  734. sf = get_seed_file([wallet] if wallet else [],1)
  735. from .wallet import Wallet
  736. return Wallet(sf).seed.subseeds.format(*SubSeedIdxRange(subseed_idx_range))
  737. def list_shares(self,
  738. share_count: int,
  739. id_str = 'default',
  740. master_share: f'(min:1, max:{MasterShareIdx.max_val}, 0=no master share)' = 0,
  741. wallet = '' ):
  742. "list the Seed IDs of the shares resulting from a split of default or specified wallet"
  743. opt.quiet = True
  744. sf = get_seed_file([wallet] if wallet else [],1)
  745. from .wallet import Wallet
  746. return Wallet(sf).seed.split(share_count,id_str,master_share).format()
  747. def gen_key(self,mmgen_addr:str,wallet=''):
  748. "generate a single MMGen WIF key from default or specified wallet"
  749. return self.gen_addr(mmgen_addr,wallet,target='wif')
  750. def gen_addr(self,mmgen_addr:str,wallet='',target='addr'):
  751. "generate a single MMGen address from default or specified wallet"
  752. addr = MMGenID(self.proto,mmgen_addr)
  753. opt.quiet = True
  754. sf = get_seed_file([wallet] if wallet else [],1)
  755. from .wallet import Wallet
  756. ss = Wallet(sf)
  757. if ss.seed.sid != addr.sid:
  758. die(1,f'Seed ID of requested address ({addr.sid}) does not match wallet ({ss.seed.sid})')
  759. al = AddrList(
  760. proto = self.proto,
  761. seed = ss.seed,
  762. addr_idxs = AddrIdxList(str(addr.idx)),
  763. mmtype = addr.mmtype )
  764. d = al.data[0]
  765. ret = d.sec.wif if target=='wif' else d.addr
  766. return ret
  767. from .tw import TwAddrList,TwUnspentOutputs
  768. class MMGenToolCmdRPC(MMGenToolCmds):
  769. "tracking wallet commands using the JSON-RPC interface"
  770. async def daemon_version(self):
  771. "print coin daemon version"
  772. from .rpc import rpc_init
  773. r = await rpc_init(self.proto,ignore_daemon_version=True)
  774. return f'{r.daemon.coind_name} version {r.daemon_version} ({r.daemon_version_str})'
  775. async def getbalance(self,minconf=1,quiet=False,pager=False):
  776. "list confirmed/unconfirmed, spendable/unspendable balances in tracking wallet"
  777. from .tw import TwGetBalance
  778. return (await TwGetBalance(self.proto,minconf,quiet)).format()
  779. async def listaddress(self,
  780. mmgen_addr:str,
  781. minconf = 1,
  782. pager = False,
  783. showempty = True,
  784. showbtcaddr = True,
  785. age_fmt: _options_annot_str(TwAddrList.age_fmts) = 'confs',
  786. ):
  787. "list the specified MMGen address and its balance"
  788. return await self.listaddresses( mmgen_addrs = mmgen_addr,
  789. minconf = minconf,
  790. pager = pager,
  791. showempty = showempty,
  792. showbtcaddrs = showbtcaddr,
  793. age_fmt = age_fmt,
  794. )
  795. async def listaddresses( self,
  796. mmgen_addrs:'(range or list)' = '',
  797. minconf = 1,
  798. showempty = False,
  799. pager = False,
  800. showbtcaddrs = True,
  801. all_labels = False,
  802. sort: _options_annot_str(['reverse','age']) = '',
  803. age_fmt: _options_annot_str(TwAddrList.age_fmts) = 'confs',
  804. ):
  805. "list MMGen addresses and their balances"
  806. show_age = bool(age_fmt)
  807. if sort:
  808. sort = set(sort.split(','))
  809. sort_params = {'reverse','age'}
  810. if not sort.issubset(sort_params):
  811. die(1,"The sort option takes the following parameters: '{}'".format( "','".join(sort_params) ))
  812. usr_addr_list = []
  813. if mmgen_addrs:
  814. a = mmgen_addrs.rsplit(':',1)
  815. if len(a) != 2:
  816. die(1,
  817. f'{mmgen_addrs}: invalid address list argument ' +
  818. '(must be in form <seed ID>:[<type>:]<idx list>)' )
  819. usr_addr_list = [MMGenID(self.proto,f'{a[0]}:{i}') for i in AddrIdxList(a[1])]
  820. al = await TwAddrList(self.proto,usr_addr_list,minconf,showempty,showbtcaddrs,all_labels)
  821. if not al:
  822. die(0,('No tracked addresses with balances!','No tracked addresses!')[showempty])
  823. return await al.format(showbtcaddrs,sort,show_age,age_fmt or 'confs')
  824. async def twview( self,
  825. pager = False,
  826. reverse = False,
  827. wide = False,
  828. minconf = 1,
  829. sort = 'age',
  830. age_fmt: _options_annot_str(TwUnspentOutputs.age_fmts) = 'confs',
  831. show_mmid = True,
  832. wide_show_confs = True):
  833. "view tracking wallet"
  834. twuo = await TwUnspentOutputs(self.proto,minconf=minconf)
  835. await twuo.get_unspent_data(reverse_sort=reverse)
  836. twuo.age_fmt = age_fmt
  837. twuo.show_mmid = show_mmid
  838. if wide:
  839. ret = twuo.format_for_printing(color=True,show_confs=wide_show_confs)
  840. else:
  841. ret = twuo.format_for_display()
  842. del twuo.wallet
  843. return await ret
  844. async def add_label(self,mmgen_or_coin_addr:str,label:str):
  845. "add descriptive label for address in tracking wallet"
  846. from .tw import TrackingWallet
  847. await (await TrackingWallet(self.proto,mode='w')).add_label(mmgen_or_coin_addr,label,on_fail='raise')
  848. return True
  849. async def remove_label(self,mmgen_or_coin_addr:str):
  850. "remove descriptive label for address in tracking wallet"
  851. await self.add_label(mmgen_or_coin_addr,'')
  852. return True
  853. async def remove_address(self,mmgen_or_coin_addr:str):
  854. "remove an address from tracking wallet"
  855. from .tw import TrackingWallet
  856. ret = await (await TrackingWallet(self.proto,mode='w')).remove_address(mmgen_or_coin_addr) # returns None on failure
  857. if ret:
  858. msg(f'Address {ret!r} deleted from tracking wallet')
  859. return ret
  860. class tool_api(
  861. MMGenToolCmdUtil,
  862. MMGenToolCmdCoin,
  863. MMGenToolCmdMnemonic,
  864. ):
  865. """
  866. API providing access to a subset of methods from the mmgen.tool module
  867. Example:
  868. from mmgen.tool import tool_api
  869. tool = tool_api()
  870. # Set the coin and network:
  871. tool.init_coin('btc','mainnet')
  872. # Print available address types:
  873. tool.print_addrtypes()
  874. # Set the address type:
  875. tool.addrtype = 'segwit'
  876. # Disable user entropy gathering (optional, reduces security):
  877. tool.usr_randchars = 0
  878. # Generate a random BTC segwit keypair:
  879. wif,addr = tool.randpair()
  880. # Set coin, network and address type:
  881. tool.init_coin('ltc','testnet')
  882. tool.addrtype = 'bech32'
  883. # Generate a random LTC testnet Bech32 keypair:
  884. wif,addr = tool.randpair()
  885. """
  886. def __init__(self):
  887. """
  888. Initializer - takes no arguments
  889. """
  890. import mmgen.opts
  891. opts.UserOpts._reset_ok += ('usr_randchars',)
  892. if not hasattr(opt,'version'):
  893. opts.init()
  894. super().__init__()
  895. def init_coin(self,coinsym,network):
  896. """
  897. Initialize a coin/network pair
  898. Valid choices for coins: one of the symbols returned by the 'coins' attribute
  899. Valid choices for network: 'mainnet','testnet','regtest'
  900. """
  901. from .protocol import init_proto,init_genonly_altcoins
  902. altcoin_trust_level = init_genonly_altcoins(coinsym,testnet=network in ('testnet','regtest'))
  903. warn_altcoins(coinsym,altcoin_trust_level)
  904. self.proto = init_proto(coinsym,network=network)
  905. return self.proto
  906. @property
  907. def coins(self):
  908. """The available coins"""
  909. from .protocol import CoinProtocol
  910. from .altcoin import CoinInfo
  911. return sorted(set(
  912. [c.upper() for c in CoinProtocol.coins]
  913. + [c.symbol for c in CoinInfo.get_supported_coins(self.proto.network)]
  914. ))
  915. @property
  916. def coin(self):
  917. """The currently configured coin"""
  918. return self.proto.coin
  919. @property
  920. def network(self):
  921. """The currently configured network"""
  922. return self.proto.network
  923. @property
  924. def addrtypes(self):
  925. """
  926. The available address types for current coin/network pair. The
  927. first-listed is the default
  928. """
  929. return [MMGenAddrType(proto=self.proto,id_str=id_str).name for id_str in self.proto.mmtypes]
  930. def print_addrtypes(self):
  931. """
  932. Print the available address types for current coin/network pair along with
  933. a description. The first-listed is the default
  934. """
  935. for t in [MMGenAddrType(proto=self.proto,id_str=id_str) for id_str in self.proto.mmtypes]:
  936. print(f'{t.name:<12} - {t.desc}')
  937. @property
  938. def addrtype(self):
  939. """The currently configured address type (is assignable)"""
  940. return self.mmtype
  941. @addrtype.setter
  942. def addrtype(self,val):
  943. self.mmtype = MMGenAddrType(self.proto,val)
  944. @property
  945. def usr_randchars(self):
  946. """
  947. The number of keystrokes of entropy to be gathered from the user.
  948. Setting to zero disables user entropy gathering.
  949. """
  950. return opt.usr_randchars
  951. @usr_randchars.setter
  952. def usr_randchars(self,val):
  953. opt.usr_randchars = val