Add limited support for electrum segwit seeds

src/seedsigner/gui/screens/seed_screens.py

@@ -427,6 +427,21 @@ def __post_init__(self):
         )
         self.components.append(self.fingerprint_icontl)
 
+class SeedSwitchElectrumModeScreen(ButtonListScreen):
+    button_data: list = None
+
+    def __post_init__(self):
+        self.show_back_button = False
+        self.title = "Switch to Electrum?"
+        self.is_bottom_list: bool = True
+
+        super().__post_init__()
+
+        self.components.append(TextArea(
+            text="It appears this is an Electrum-style seed, switch it to be so? Some functions are not supported for Electrum seeds",
+            screen_y=self.top_nav.height + GUIConstants.COMPONENT_PADDING,
+            is_text_centered=True,
+        ))
 
 
 @dataclass

src/seedsigner/helpers/embit_utils.py

@@ -19,7 +19,7 @@
 # TODO: PR these directly into `embit`? Or replace with new/existing methods already in `embit`?
 
 
-def get_standard_derivation_path(network: str = SettingsConstants.MAINNET, wallet_type: str = SettingsConstants.SINGLE_SIG, script_type: str = SettingsConstants.NATIVE_SEGWIT) -> str:
+def get_standard_derivation_path(network: str = SettingsConstants.MAINNET, wallet_type: str = SettingsConstants.SINGLE_SIG, script_type: str = SettingsConstants.NATIVE_SEGWIT, is_electrum : bool = False) -> str:
     if network == SettingsConstants.MAINNET:
         network_path = "0'"
     elif network == SettingsConstants.TESTNET:
@@ -31,6 +31,8 @@ def get_standard_derivation_path(network: str = SettingsConstants.MAINNET, walle
 
     if wallet_type == SettingsConstants.SINGLE_SIG:
         if script_type == SettingsConstants.NATIVE_SEGWIT:
+            if is_electrum:
+                return f"m/0h"
             return f"m/84'/{network_path}/0'"
         elif script_type == SettingsConstants.NESTED_SEGWIT:
             return f"m/49'/{network_path}/0'"
@@ -41,6 +43,8 @@ def get_standard_derivation_path(network: str = SettingsConstants.MAINNET, walle
 
     elif wallet_type == SettingsConstants.MULTISIG:
         if script_type == SettingsConstants.NATIVE_SEGWIT:
+            if is_electrum:
+                return f"m/1h"
             return f"m/48'/{network_path}/0'/2'"
         elif script_type == SettingsConstants.NESTED_SEGWIT:
             return f"m/48'/{network_path}/0'/1'"
@@ -52,6 +56,12 @@ def get_standard_derivation_path(network: str = SettingsConstants.MAINNET, walle
         raise Exception("Unexpected wallet type")    # checks that all inputs are from the same wallet
 
 
+def detect_version(derivation_path: str, network: str = SettingsConstants.MAINNET, wallet_type: str = SettingsConstants.SINGLE_SIG, is_electrum : bool = False) -> str:
+    embit_network = NETWORKS[SettingsConstants.map_network_to_embit(network)]
+    if is_electrum:
+        return embit_network["zpub"] if SettingsConstants.SINGLE_SIG == wallet_type else embit_network["Zpub"]
+    else:
+        return embit.bip32.detect_version(derivation_path, default="xpub", network=embit_network)
 
 def get_xpub(seed_bytes, derivation_path: str, embit_network: str = "main") -> HDKey:
     root = bip32.HDKey.from_seed(seed_bytes, version=NETWORKS[embit_network]["xprv"])

src/seedsigner/models/encode_qr.py

@@ -11,6 +11,7 @@
 from seedsigner.helpers.ur2.ur_encoder import UREncoder
 from seedsigner.helpers.ur2.ur import UR
 from seedsigner.helpers.qr import QR
+from seedsigner.helpers import embit_utils
 from seedsigner.models.qr_type import QRType
 from seedsigner.models.seed import Seed
 from seedsigner.models.settings import SettingsConstants
@@ -40,6 +41,8 @@ class EncodeQR:
     wordlist_language_code: str = SettingsConstants.WORDLIST_LANGUAGE__ENGLISH
     bitcoin_address: str = None
     signed_message: str = None
+    is_electrum : bool = False
+    sig_type : str = SettingsConstants.SINGLE_SIG
 
     def __post_init__(self):
         self.qr = QR()
@@ -66,7 +69,9 @@ def __post_init__(self):
                 passphrase=self.passphrase,
                 derivation=self.derivation,
                 network=self.network,
-                wordlist_language_code=self.wordlist_language_code
+                wordlist_language_code=self.wordlist_language_code,
+                is_electrum=self.is_electrum,
+                sig_type=self.sig_type
             )
 
         elif self.qr_type == QRType.XPUB__UR:
@@ -76,7 +81,9 @@ def __post_init__(self):
                 passphrase=self.passphrase,
                 derivation=self.derivation,
                 network=self.network,
-                wordlist_language_code=self.wordlist_language_code
+                wordlist_language_code=self.wordlist_language_code,
+                is_electrum=self.is_electrum,
+                sig_type=self.sig_type
             )
 
         elif self.qr_type == QRType.XPUB__SPECTER:
@@ -86,7 +93,9 @@ def __post_init__(self):
                 passphrase=self.passphrase,
                 derivation=self.derivation,
                 network=self.network,
-                wordlist_language_code=self.wordlist_language_code
+                wordlist_language_code=self.wordlist_language_code,
+                is_electrum=self.is_electrum,
+                sig_type=self.sig_type
             )
 
 
@@ -356,7 +365,7 @@ def next_part(self):
 
 
 class XpubQrEncoder(BaseQrEncoder):
-    def __init__(self, seed_phrase, passphrase, derivation, network, wordlist_language_code):
+    def __init__(self, seed_phrase, passphrase, derivation, network, wordlist_language_code, is_electrum : bool = False, sig_type : str = SettingsConstants.SINGLE_SIG):
         self.seed_phrase = seed_phrase
         self.passphrase = passphrase
         self.derivation = derivation
@@ -369,10 +378,12 @@ def __init__(self, seed_phrase, passphrase, derivation, network, wordlist_langua
         if self.wordlist == None:
             raise Exception('Wordlist Required')
 
-        version = bip32.detect_version(self.derivation, default="xpub", network=NETWORKS[SettingsConstants.map_network_to_embit(self.network)])
         self.seed = Seed(mnemonic=self.seed_phrase,
                          passphrase=self.passphrase,
                          wordlist_language_code=wordlist_language_code)
+        if is_electrum:
+            self.seed.switch_to_electrum()
+        version = embit_utils.detect_version(self.derivation, network, sig_type, self.seed.is_electrum)
         self.root = bip32.HDKey.from_seed(self.seed.seed_bytes, version=NETWORKS[SettingsConstants.map_network_to_embit(self.network)]["xprv"])
         self.fingerprint = self.root.child(0).fingerprint
         self.xprv = self.root.derive(self.derivation)

src/seedsigner/models/seed.py

@@ -1,4 +1,6 @@
 import unicodedata
+import hashlib
+import hmac
 
 from binascii import hexlify
 from embit import bip39, bip32, bip85
@@ -25,9 +27,11 @@ def __init__(self,
         self._mnemonic: List[str] = unicodedata.normalize("NFKD", " ".join(mnemonic).strip()).split()
 
         self._passphrase: str = ""
+        self._is_electrum = False
         self.set_passphrase(passphrase, regenerate_seed=False)
 
         self.seed_bytes: bytes = None
+        self.electrum_seed_bytes: bytes = None
         self._generate_seed()
 
 
@@ -42,11 +46,42 @@ def get_wordlist(wordlist_language_code: str = SettingsConstants.WORDLIST_LANGUA
 
     def _generate_seed(self) -> bool:
         try:
-            self.seed_bytes = bip39.mnemonic_to_seed(self.mnemonic_str, password=self._passphrase, wordlist=self.wordlist)
+            self._generate_electrum_seed()
+            if not self.is_electrum:
+                # only do regular bip39 if not already confirmed this seed is_electrum (i.e. during passphrase change)
+                self.seed_bytes = bip39.mnemonic_to_seed(self.mnemonic_str, password=self._passphrase, wordlist=self.wordlist)
         except Exception as e:
             print(repr(e))
-            raise InvalidSeedException(repr(e))
+            # only re-raise if we didn't get valid electrum seed
+            # we can raise in the electrum confirmation if they didn't mean to enter an electrum seed
+            if not self.electrum_seed_bytes:
+                raise InvalidSeedException(repr(e))
+
+    def _generate_electrum_seed(self) -> bool:
+        if len(self._mnemonic) != 12:
+            return False
+        s = hmac.digest(b"Seed version", self.mnemonic_str.encode('utf8'), hashlib.sha512).hex()
+        if s[0] != '0' and s[0] != '1':
+            return False
+        length = int(s[0]) + 2
+        prefix = s[0:length];
+        # only support Electrum Segwit version for now
+        if SettingsConstants.ELECTRUM_SEED_SEGWIT == prefix:
+            self.electrum_seed_bytes=hashlib.pbkdf2_hmac('sha512', self.mnemonic_str.encode('utf-8'), b'electrum' + self._passphrase.encode('utf-8'), iterations = SettingsConstants.ELECTRUM_PBKDF2_ROUNDS)
+            if self.is_electrum:
+                # if already is_electrum (passphrase change), make sure to set main seed_bytes
+                self.seed_bytes = self.electrum_seed_bytes
+            return True
+        else:
+            return False
+
+    def switch_to_electrum(self):
+        self.seed_bytes = self.electrum_seed_bytes
+        self._is_electrum = True
 
+    @property
+    def is_electrum(self) -> bool:
+        return self._is_electrum
 
     @property
     def mnemonic_str(self) -> str:
@@ -81,6 +116,8 @@ def passphrase_display(self):
     def set_passphrase(self, passphrase: str, regenerate_seed: bool = True):
         if passphrase:
             self._passphrase = unicodedata.normalize("NFKD", passphrase)
+            if self.is_electrum:
+                self._passphrase = Seed.normalize_electrum_passphrase(passphrase)
         else:
             # Passphrase must always have a string value, even if it's just the empty
             # string.
@@ -90,6 +127,14 @@ def set_passphrase(self, passphrase: str, regenerate_seed: bool = True):
             # Regenerate the internal seed since passphrase changes the result
             self._generate_seed()
 
+    @staticmethod
+    def normalize_electrum_passphrase(passphrase : str) -> str:
+        passphrase = unicodedata.normalize('NFKD', passphrase)
+        # lower
+        passphrase = passphrase.lower()
+        # normalize whitespaces
+        passphrase = u' '.join(passphrase.split())
+        return passphrase
 
     @property
     def wordlist(self) -> List[str]:

src/seedsigner/models/settings_definition.py

@@ -198,6 +198,11 @@ def map_network_to_embit(cls, network) -> str:
         TYPE__ENABLED_DISABLED_PROMPT_REQUIRED,
     ]
 
+    # Electrum seed constants
+    ELECTRUM_SEED_LEGACY = "01"
+    ELECTRUM_SEED_SEGWIT = "100"
+    ELECTRUM_SEED_2FA = "101"
+    ELECTRUM_PBKDF2_ROUNDS=2048
 
 @dataclass
 class SettingsEntry:

src/seedsigner/views/seed_views.py

@@ -289,6 +289,9 @@ def run(self):
 class SeedFinalizeView(View):
     FINALIZE = "Done"
     PASSPHRASE = "BIP-39 Passphrase"
+    CUSTOM_EXTENSION = "Custom Extension"
+    SWITCH = "Switch"
+    CANCEL = "Cancel"
 
     def __init__(self):
         super().__init__()
@@ -297,9 +300,26 @@ def __init__(self):
 
 
     def run(self):
+        if self.seed.electrum_seed_bytes:
+            # see if user wants to enter electrum mode since it's a valid electrum seed
+            button_data = [self.SWITCH, self.CANCEL]
+            selected_menu_num = self.run_screen(
+                    seed_screens.SeedSwitchElectrumModeScreen,
+                    button_data=button_data
+                    )
+            if button_data[selected_menu_num] == self.SWITCH:
+                self.seed.switch_to_electrum()
+                # recalculate fingerprint
+                self.fingerprint = self.seed.get_fingerprint(network=self.settings.get_value(SettingsConstants.SETTING__NETWORK))
+            elif not self.seed.seed_bytes: 
+                # we only got here because it was a valid electrum seed
+                # thus if user didn't mean to enter an electrum seed, it's invalid
+                raise InvalidSeedException(f"Invalid seed entered")
+
         button_data = [self.FINALIZE]
+        passphrase_button = self.CUSTOM_EXTENSION if self.seed.is_electrum else self.PASSPHRASE
         if self.settings.get_value(SettingsConstants.SETTING__PASSPHRASE) != SettingsConstants.OPTION__DISABLED:
-            button_data.append(self.PASSPHRASE)
+            button_data.append(passphrase_button)
 
         selected_menu_num = self.run_screen(
             seed_screens.SeedFinalizeScreen,
@@ -311,7 +331,7 @@ def run(self):
             seed_num = self.controller.storage.finalize_pending_seed()
             return Destination(SeedOptionsView, view_args={"seed_num": seed_num}, clear_history=True)
 
-        elif button_data[selected_menu_num] == self.PASSPHRASE:
+        elif button_data[selected_menu_num] == passphrase_button:
             return Destination(SeedAddPassphraseView)
 
 
@@ -323,7 +343,8 @@ def __init__(self):
 
 
     def run(self):
-        ret = self.run_screen(seed_screens.SeedAddPassphraseScreen, passphrase=self.seed.passphrase)
+        passphrase_title="Custom Extension" if self.seed.is_electrum else "BIP-39 Passphrase"
+        ret = self.run_screen(seed_screens.SeedAddPassphraseScreen, passphrase=self.seed.passphrase, title=passphrase_title)
 
         if ret == RET_CODE__BACK_BUTTON:
             return Destination(BackStackView)
@@ -612,7 +633,9 @@ def __init__(self, seed_num: int, sig_type: str):
     def run(self):
         from .tools_views import ToolsAddressExplorerAddressTypeView
         args = {"seed_num": self.seed_num, "sig_type": self.sig_type}
-        if len(self.settings.get_value(SettingsConstants.SETTING__SCRIPT_TYPES)) == 1:
+        seed = self.controller.storage.seeds[self.seed_num]
+        script_types = [SettingsConstants.NATIVE_SEGWIT] if seed.is_electrum else self.settings.get_value(SettingsConstants.SETTING__SCRIPT_TYPES)
+        if len(script_types) == 1:
             # Nothing to select; skip this screen
             args["script_type"] = self.settings.get_value(SettingsConstants.SETTING__SCRIPT_TYPES)[0]
 
@@ -799,7 +822,8 @@ def run(self):
             derivation_path = embit_utils.get_standard_derivation_path(
                 network=self.settings.get_value(SettingsConstants.SETTING__NETWORK),
                 wallet_type=self.sig_type,
-                script_type=self.script_type
+                script_type=self.script_type,
+                is_electrum=self.seed.is_electrum
             )
 
         if self.settings.get_value(SettingsConstants.SETTING__XPUB_DETAILS) == SettingsConstants.OPTION__DISABLED:
@@ -814,10 +838,11 @@ def run(self):
 
             try:
                 embit_network = NETWORKS[SettingsConstants.map_network_to_embit(self.settings.get_value(SettingsConstants.SETTING__NETWORK))]
-                version = embit.bip32.detect_version(
-                    derivation_path,
-                    default="xpub",
-                    network=embit_network
+                version = embit_utils.detect_version(
+                        derivation_path,
+                        self.settings.get_value(SettingsConstants.SETTING__NETWORK),
+                        self.sig_type,
+                        self.seed.is_electrum
                 )
                 root = embit.bip32.HDKey.from_seed(
                     self.seed.seed_bytes,
@@ -845,6 +870,7 @@ def run(self):
                 dict(seed_num=self.seed_num,
                      coordinator=self.coordinator,
                      derivation_path=derivation_path,
+                     sig_type=self.sig_type
                 )
             )
 
@@ -854,7 +880,7 @@ def run(self):
 
 
 class SeedExportXpubQRDisplayView(View):
-    def __init__(self, seed_num: int, coordinator: str, derivation_path: str):
+    def __init__(self, seed_num: int, coordinator: str, derivation_path: str, sig_type: str = SettingsConstants.SINGLE_SIG):
         super().__init__()
         self.seed = self.controller.get_seed(seed_num)
 
@@ -884,7 +910,9 @@ def __init__(self, seed_num: int, coordinator: str, derivation_path: str):
             network=self.settings.get_value(SettingsConstants.SETTING__NETWORK),
             qr_type=qr_type,
             qr_density=qr_density,
-            wordlist_language_code=self.seed.wordlist_language_code
+            wordlist_language_code=self.seed.wordlist_language_code,
+            is_electrum=self.seed.is_electrum,
+            sig_type=sig_type
         )
 
 
@@ -1299,7 +1327,7 @@ def run(self):
             num_modules_standard = 29
             num_modules_compact = 25
 
-        if self.settings.get_value(SettingsConstants.SETTING__COMPACT_SEEDQR) != SettingsConstants.OPTION__ENABLED:
+        if seed.is_electrum or self.settings.get_value(SettingsConstants.SETTING__COMPACT_SEEDQR) != SettingsConstants.OPTION__ENABLED:
             # Only configured for standard SeedQR
             return Destination(
                 SeedTranscribeSeedQRWarningView,
@@ -1650,6 +1678,9 @@ def __init__(self, seed_num: int = None):
         else:
             self.seed = None
         self.address = self.controller.unverified_address["address"]
+        # override derivation path if it's electrum as bip-39 path was set by default
+        if self.seed and self.seed.is_electrum:
+            self.controller.unverified_address["derivation_path"] = 'm/0h'
         self.derivation_path = self.controller.unverified_address["derivation_path"]
         self.script_type = self.controller.unverified_address["script_type"]
         self.sig_type = self.controller.unverified_address["sig_type"]

src/seedsigner/views/tools_views.py

@@ -534,6 +534,7 @@ def __init__(self, seed_num: int = None, script_type: str = None, custom_derivat
                     network=self.settings.get_value(SettingsConstants.SETTING__NETWORK),
                     wallet_type=SettingsConstants.SINGLE_SIG,
                     script_type=self.script_type,
+                    is_electrum = self.seed.is_electrum
                 )
 
             data["derivation_path"] = derivation_path