Extend Wallet Import Format with txin type. Extend class Imported_Wallet.

lib/keystore.py

@@ -141,24 +141,22 @@ class Imported_KeyStore(Software_KeyStore):
         pubkey = list(self.keypairs.keys())[0]
         self.get_private_key(pubkey, password)
 
-    def import_key(self, sec, password):
-        try:
-            pubkey = public_key_from_private_key(sec)
-        except Exception:
-            raise BaseException('Invalid private key')
-        # allow overwrite
+    def import_privkey(self, sec, password):
+        txin_type, privkey, compressed = deserialize_privkey(sec)
+        pubkey = public_key_from_private_key(privkey, compressed)
         self.keypairs[pubkey] = pw_encode(sec, password)
-        return pubkey
+        return txin_type, pubkey
 
     def delete_imported_key(self, key):
         self.keypairs.pop(key)
 
     def get_private_key(self, pubkey, password):
-        pk = pw_decode(self.keypairs[pubkey], password)
+        sec = pw_decode(self.keypairs[pubkey], password)
+        txin_type, privkey, compressed = deserialize_privkey(sec)
         # this checks the password
-        if pubkey != public_key_from_private_key(pk):
+        if pubkey != public_key_from_private_key(privkey, compressed):
             raise InvalidPassword()
-        return pk
+        return privkey
 
     def get_pubkey_derivation(self, x_pubkey):
         if x_pubkey[0:2] in ['02', '03', '04']:
@@ -180,8 +178,6 @@ class Imported_KeyStore(Software_KeyStore):
             c = pw_encode(b, new_password)
             self.keypairs[k] = c
 
-    def txin_type(self):
-        return 'p2pkh'
 
 
 class Deterministic_KeyStore(Software_KeyStore):
@@ -277,17 +273,6 @@ class Xpub:
             return
         return derivation
 
-    def txin_type(self):
-        xtype = deserialize_xpub(self.xpub)[0]
-        if xtype == 'standard':
-            return 'p2pkh'
-        elif xtype == 'segwit':
-            return 'p2wpkh'
-        elif xtype == 'segwit_p2sh':
-            return 'p2wpkh-p2sh'
-        else:
-            raise BaseException('unknown txin_type', xtype)
-
 
 class BIP32_KeyStore(Deterministic_KeyStore, Xpub):
 
@@ -411,11 +396,6 @@ class Old_KeyStore(Deterministic_KeyStore):
     def get_sequence(self, mpk, for_change, n):
         return string_to_number(Hash(("%d:%d:"%(n, for_change)).encode('ascii') + bfh(mpk)))
 
-    def get_address(self, for_change, n):
-        pubkey = self.get_pubkey(for_change, n)
-        address = public_key_to_p2pkh(bfh(pubkey))
-        return address
-
     @classmethod
     def get_pubkey_from_mpk(self, mpk, for_change, n):
         z = self.get_sequence(mpk, for_change, n)
@@ -431,8 +411,7 @@ class Old_KeyStore(Deterministic_KeyStore):
         order = generator_secp256k1.order()
         secexp = (secexp + self.get_sequence(self.mpk, for_change, n)) % order
         pk = number_to_string(secexp, generator_secp256k1.order())
-        compressed = False
-        return SecretToASecret(pk, compressed)
+        return pk
 
     def get_private_key(self, sequence, password):
         seed = self.get_hex_seed(password)
@@ -491,8 +470,6 @@ class Old_KeyStore(Deterministic_KeyStore):
             decoded = pw_decode(self.seed, old_password)
             self.seed = pw_encode(decoded, new_password)
 
-    def txin_type(self):
-        return 'p2phk'
 
 
 class Hardware_KeyStore(KeyStore, Xpub):
@@ -692,7 +669,7 @@ def is_private_key_list(text):
 
 is_mpk = lambda x: is_old_mpk(x) or is_xpub(x)
 is_private = lambda x: is_seed(x) or is_xprv(x) or is_private_key_list(x)
-is_any_key = lambda x: is_old_mpk(x) or is_xprv(x) or is_xpub(x) or is_private_key_list(x)
+is_master_key = lambda x: is_old_mpk(x) or is_xprv(x) or is_xpub(x)
 is_private_key = lambda x: is_xprv(x) or is_private_key_list(x)
 is_bip32_key = lambda x: is_xprv(x) or is_xpub(x)
 
@@ -740,15 +717,13 @@ def from_xprv(xprv):
     k.xpub = xpub
     return k
 
-def from_keys(text):
+def from_master_key(text):
     if is_xprv(text):
         k = from_xprv(text)
     elif is_old_mpk(text):
         k = from_old_mpk(text)
     elif is_xpub(text):
         k = from_xpub(text)
-    elif is_private_key_list(text):
-        k = from_private_key_list(text)
     else:
         raise BaseException('Invalid key')
     return k