slip39.App works

Author: pjkundert

SLIP39.py

@@ -1,28 +1,33 @@
 import argparse
 import logging
 import math
-import sys
+import os
 
 import PySimpleGUI as sg
 
 from ..types		import Account
 from ..api		import create, group_parser
 from ..util		import log_level, log_cfg
-from ..defaults		import GROUPS, GROUP_THRESHOLD_RATIO
+from ..layout		import write_pdfs
+from ..defaults		import GROUPS, GROUP_THRESHOLD_RATIO, CRYPTO_PATHS
 
-font				= ('Sans', 12)
+log				= logging.getLogger( __package__ )
+
+font				= ('Courier', 14)
 
 I_kwds				= dict(
     change_submits	= True,
     font		= font,
 )
-
 T_kwds				= dict(
     font		= font,
 )
+B_kwds				= dict(
+    font		= font,
+)
 
 
-def groups_layout( names, group_threshold, groups ):
+def groups_layout( names, group_threshold, groups, passphrase=None ):
     """Return a layout for the specified number of SLIP-39 groups.
 
     """
@@ -52,21 +57,37 @@ def groups_layout( names, group_threshold, groups ):
             ], key='-GROUP-SIZES-' ) ]]
         ),
     ]
-
+    prefix			= (30,1)
     layout			= [
         [
+            sg.Text( "Save PDF to (ie. USB drive): ", size=prefix, **T_kwds ),
+            sg.Input( sg.user_settings_get_entry( "-target folder-", ""), k='-TARGET-', **I_kwds ),
+            sg.FolderBrowse( **B_kwds )
+        ],
+    ] + [
+        [
+            sg.Text( "Seed File Name(s): ", size=prefix, **T_kwds ),
             sg.Input( f"{', '.join( names )}", key='-NAMES-', **I_kwds ),
-            sg.Text( "Requires collection of at least", **T_kwds ),
+            sg.Text( "(comma-separted)", **T_kwds ),
+        ]
+    ] + [
+        [
+            sg.Text( "Requires recovery of at least: ", size=prefix, **T_kwds ),
             sg.Input( f"{group_threshold}", key='-THRESHOLD-', **I_kwds ),
-            sg.Text( f" of {len(groups)} SLIP-39 Recovery Groups", **T_kwds ),
+            sg.Text( f" of {len(groups)} SLIP-39 Recovery Groups", key='-RECOVERY-', **T_kwds ),
+        ],
+    ] + [
+        [
+            sg.Text( "Passphrase to encrypt Seed: ", size=prefix, **T_kwds ),
+            sg.Input( f"{passphrase or ''}", key='-PASSPHRASE-', **I_kwds ),
         ],
     ] + [
         [
             sg.Frame( 'Groups', [group_body], key='-GROUPS-' ),
         ],
     ] + [
         [
-            sg.Button( '+' ), sg.Button( 'Generate' ), sg.Exit()
+            sg.Button( '+', **B_kwds ), sg.Button( 'Save', **B_kwds ), sg.Exit()
         ],
         [
             sg.Frame(
@@ -80,28 +101,70 @@ def groups_layout( names, group_threshold, groups ):
                 [[ sg.Text( key='-STATUS-', **T_kwds ), ]]
             ),
         ],
-
     ]
     return layout
 
 
-def app( names, group_threshold, groups, cryptopaths ):
+def app(
+    names			= None,
+    group			= None,
+    threshold			= None,
+    cryptocurrency		= None,
+    passphrase			= None,
+):
+    # Convert sequence of group specifications into standard { "<group>": (<needs>, <size>) ... }
+    if isinstance( group, dict ):
+        groups			= group
+    else:
+        groups			= dict(
+            group_parser( g )
+            for g in group or GROUPS
+        )
+    assert groups and all( isinstance( k, str ) and len( v ) == 2 for k,v in groups.items() ), \
+        f"Each group member specification must be a '<group>': (<needs>, <size>) pair, not {type(next(groups.items()))}"
+
+    group_threshold		= int( threshold ) if threshold else math.ceil( len( groups ) * GROUP_THRESHOLD_RATIO )
+
+    cryptopaths			= []
+    for crypto in cryptocurrency or CRYPTO_PATHS:
+        try:
+            if isinstance( crypto, str ):
+                crypto,paths	= crypto.split( ':' )   # Find the  <crypto>,<path> tuple
+            else:
+                crypto,paths	= crypto		# Already a <crypto>,<path> tuple?
+        except ValueError:
+            crypto,paths	= crypto,None
+        cryptopaths.append( (crypto,paths) )
+
     sg.theme( 'DarkAmber' )
 
-    layout			= groups_layout( names, group_threshold, groups )
+    sg.user_settings_set_entry( '-target folder-', os.getcwd() )
+
+    layout			= groups_layout( names, group_threshold, groups, passphrase )
     window			= None
     status			= None
     event			= False
     while event not in (sg.WIN_CLOSED, 'Exit',):
+        # Create window (for initial window.read()), or update status
         if window:
             window['-STATUS-'].update( status or 'OK' )
+            window['-RECOVERY-'].update( f"of {len(groups)} SLIP-39 Recovery Groups", **T_kwds ),
         else:
             window		= sg.Window( f"{', '.join( names )} Mnemonic Cards", layout )
 
         status			= None
         event, values		= window.read()
         logging.info( f"{event}, {values}" )
 
+        if '-TARGET-' in values:
+            # A target directory has been selected;
+            try:
+                os.chdir( values['-TARGET-'] )
+            except Exception as exc:
+                status		= f"Error changing to target directory {values['-TARGET-']}: {exc}"
+                logging.exception( f"{status}" )
+                continue
+
         if event == '+':
             g			= len(groups)
             name		= f"Group {g+1}"
@@ -112,55 +175,68 @@ def app( names, group_threshold, groups, cryptopaths ):
             window.extend_layout( window['-GROUP-NEEDS-'],  [[ sg.Input( f"{needs[0]}", key=f"-G-NEED-{g}", **I_kwds ) ]] )  # noqa: 241
             window.extend_layout( window['-GROUP-SIZES-'],  [[ sg.Input( f"{needs[1]}", key=f"-G-SIZE-{g}", **I_kwds ) ]] )  # noqa: 241
 
-        if event == 'Generate':
+        try:
+            g_thr_val		= values['-THRESHOLD-']
+            g_thr		= int( g_thr_val )
+        except Exception as exc:
+            status		= f"Error defining group threshold {g_thr_val}: {exc}"
+            logging.exception( f"{status}" )
+            continue
+
+        g_rec			= {}
+        status			= None
+        for g in range( 16 ):
+            grp_idx		= f"-G-NAME-{g}"
+            if grp_idx not in values:
+                break
+            grp			= '?'
             try:
-                g_thr_val	= values['-THRESHOLD-']
-                g_thr		= int( g_thr_val )
+                grp		= str( values[grp_idx] )
+                g_rec[grp] 	= int( values[f"-G-NEED-{g}"] or 0 ), int( values[f"-G-SIZE-{g}"] or 0 )
             except Exception as exc:
-                status		= f"Error defining group threshold {g_thr_val}: {exc}"
+                status		= f"Error defining group {g+1} {grp!r}: {exc}"
                 logging.exception( f"{status}" )
                 continue
 
-            g_rec		= {}
-            status		= None
-            for g in range( 16 ):
-                nam_idx		= f"-G-NAME-{g}"
-                if nam_idx not in values:
-                    break
-                try:
-                    nam		= values[nam_idx]
-                    req,siz	= int( values[f"-G-NEED-{g}"] ), int( values[f"-G-SIZE-{g}"] )
-                    g_rec[nam] 	= (req, siz)
-                except Exception as exc:
-                    status	= f"Error defining group {g+1}: {exc}"
-                    logging.exception( f"{status}" )
-                    continue
-
-            summary		= f"Require {g_thr}/{len(g_rec)} Groups, from: {f', '.join( f'{n}({need}/{size})' for n,(need,size) in g_rec.items())}" 
-            window['-SUMMARY-'].update( summary )
-            if status is None:
-                details		= {}
-                try:
-                    for name in names:
-                        details[name]	= create(
-                            name		= name,
-                            group_threshold	= group_threshold,
-                            groups		= g_rec,
-                            cryptopaths		= cryptopaths,
-                    )
-                except Exception as exc:
-                    status	= f"Error creating: {exc}"
-                    logging.exception( f"{status}" )
-                    continue
-
-                status		= 'OK'
-                for n in names:
-                    accts	= ', '.join( f'{a.crypto} @ {a.path}: {a.address}' for a in details[n].accounts[0] )
-                    status     += f"; {accts}"
+        summary			= f"Require {g_thr}/{len(g_rec)} Groups, from: {f', '.join( f'{n}({need}/{size})' for n,(need,size) in g_rec.items())}"
+        passphrase		= values['-PASSPHRASE-'].strip()
+        if passphrase:
+            summary	       += f", decrypted w/ passphrase {passphrase!r}"
+        window['-SUMMARY-'].update( summary )
 
-    window.close()
+        names			= [
+            name.strip()
+            for name in values['-NAMES-'].split( ',' )
+            if name
+        ]
+        details			= {}
+        try:
+            for name in names or [ "SLIP39" ]:
+                details[name]	= create(
+                    name		= name,
+                    group_threshold	= group_threshold,
+                    groups		= g_rec,
+                    cryptopaths		= cryptopaths,
+                    passphrase		= passphrase.encode( 'utf-8' ) if passphrase else b'',
+                )
+        except Exception as exc:
+            status		= f"Error creating: {exc}"
+            logging.exception( f"{status}" )
+            continue
 
-    return 0
+        # If we get here, no failure status has been detected; we could save (details is now { "<filename>": <details> })
+        if event == 'Save':
+            details		= write_pdfs(
+                names	= details,
+            )
+
+        name_len		= max( len( name ) for name in details )
+        status			= '\n'.join(
+            f"{name:>{name_len}} == " + ', '.join( f'{a.crypto} @ {a.path}: {a.address}' for a in details[name].accounts[0] )
+            for name in details
+        )
+
+    window.close()
 
 
 def main( argv=None ):
@@ -181,6 +257,9 @@ def main( argv=None ):
     ap.add_argument( '-c', '--cryptocurrency', action='append',
                      default=[],
                      help=f"A crypto name and optional derivation path ('../<range>/<range>' allowed); defaults: {', '.join( f'{c}:{Account.path_default(c)}' for c in Account.CRYPTOCURRENCIES)}" )
+    ap.add_argument( '--passphrase',
+                     default=None,
+                     help="Encrypt the master secret w/ this passphrase, '-' reads it from stdin (default: None/'')" )
     ap.add_argument( 'names', nargs="*",
                      help="Account names to produce")
     args			= ap.parse_args( argv )
@@ -192,26 +271,15 @@ def main( argv=None ):
     if args.verbose:
         logging.getLogger().setLevel( log_cfg['level'] )
 
-    names			= args.names or [ 'SLIP-39' ]
-    groups			= dict(
-        group_parser( g )
-        for g in args.group or GROUPS
-    )
-    group_threshold		= args.threshold or math.ceil( len( groups ) * GROUP_THRESHOLD_RATIO )
-
-    cryptopaths			= []
-    for crypto in args.cryptocurrency or ['ETH', 'BTC']:
-        try:
-            crypto,paths	= crypto.split( ':' )
-        except ValueError:
-            crypto,paths	= crypto,None
-        cryptopaths.append( (crypto,paths) )
-
-    sys.exit(
+    try:
         app(
-            names		= names,
-            group_threshold	= group_threshold,
-            groups		= groups,
-            cryptopaths		= cryptopaths,
+            names		= args.names,
+            threshold		= args.threshold,
+            group		= args.group,
+            cryptocurrency	= args.cryptocurrency,
+            passphrase		= args.passphrase,
         )
-    )
+    except Exception as exc:
+        log.exception( f"Failed running App: {exc}" )
+        return 1
+    return 0

slip39/App/main.py

@@ -69,3 +69,9 @@
 
 
 BAUDRATE			= 115200
+
+FILENAME_KEYWORDS		= [ 'name', 'date', 'time', 'crypto', 'path', 'address' ]
+FILENAME_FORMAT			= "{name}-{date}+{time}-{crypto}-{address}.pdf"
+
+# Default Crypto accounts (and optional paths) to generate
+CRYPTO_PATHS			= [ 'ETH', 'BTC' ]