fix: pending accounts

[electrum-nvc.git] / lib / wallet.py

diff --git a/lib/wallet.py b/lib/wallet.py
index 05572d3..ccb6855 100644 (file)
--- a/lib/wallet.py
+++ b/lib/wallet.py
@@ -177,6 +177,8 @@ class Abstract_Wallet:
         self.addressbook           = storage.get('contacts', [])
 
         self.imported_keys         = storage.get('imported_keys',{})
+        self.imported_account      = ImportedAccount(self.imported_keys)
+
         self.history               = storage.get('addr_history',{})        # address -> list(txid, height)
 
         self.fee                   = int(storage.get('fee_per_kb', 10000))
@@ -249,14 +251,11 @@ class Abstract_Wallet:
     def synchronize(self):
         pass
 
-    def get_pending_accounts(self):
-        return {}
-            
     def can_create_accounts(self):
         return False
 
     def check_password(self, password):
-        pass
+        raise
 
 
     def set_up_to_date(self,b):
@@ -332,7 +331,7 @@ class Abstract_Wallet:
 
 
     def is_mine(self, address):
-        return address in self.addresses(True)
+        return address in self.addresses(True) 
 
 
     def is_change(self, address):
@@ -564,7 +563,7 @@ class Abstract_Wallet:
 
 
     def get_addr_balance(self, address):
-        assert self.is_mine(address)
+        #assert self.is_mine(address)
         h = self.history.get(address,[])
         if h == ['*']: return 0,0
         c = u = 0
@@ -636,7 +635,7 @@ class Abstract_Wallet:
             o = self.addresses(True)
         elif a == -1:
             o = self.imported_keys.keys()
-        else:
+        elif a in self.accounts:
             ac = self.accounts[a]
             o = ac.get_addresses(0)
             if include_change: o += ac.get_addresses(1)
@@ -1125,6 +1124,16 @@ class Imported_Wallet(Abstract_Wallet):
     def is_deterministic(self):
         return False
 
+    def check_password(self, password):
+        if self.imported_keys:
+            k, v = self.imported_keys.items()[0]
+            sec = pw_decode(v, password)
+            address = address_from_private_key(sec)
+            assert address == k
+
+    def get_accounts(self):
+        return { -1:self.imported_account }
+
 
 
 class Deterministic_Wallet(Abstract_Wallet):
@@ -1144,6 +1153,22 @@ class Deterministic_Wallet(Abstract_Wallet):
     def check_password(self, password):
         self.get_seed(password)
 
+    def add_seed(self, seed, password):
+        if self.seed: 
+            raise Exception("a seed exists")
+        
+        self.seed_version, self.seed = self.prepare_seed(seed)
+        if password: 
+            self.seed = pw_encode( self.seed, password)
+            self.use_encryption = True
+        else:
+            self.use_encryption = False
+
+        self.storage.put('seed', self.seed, True)
+        self.storage.put('seed_version', self.seed_version, True)
+        self.storage.put('use_encryption', self.use_encryption,True)
+        self.create_master_keys(password)
+
     def get_seed(self, password):
         s = pw_decode(self.seed, password)
         seed = mnemonic_to_seed(s,'').encode('hex')
@@ -1255,6 +1280,8 @@ class Deterministic_Wallet(Abstract_Wallet):
         self.check_pending_accounts()
         new = []
         for account in self.accounts.values():
+            if type(account) == PendingAccount:
+                continue
             new += self.synchronize_account(account)
         if new:
             self.save_accounts()
@@ -1307,9 +1334,6 @@ class Deterministic_Wallet(Abstract_Wallet):
 
     def add_account(self, account_id, account):
         self.accounts[account_id] = account
-        if account_id in self.pending_accounts:
-            self.pending_accounts.pop(account_id)
-            self.storage.put('pending_accounts', self.pending_accounts)
         self.save_accounts()
 
 
@@ -1334,27 +1358,31 @@ class Deterministic_Wallet(Abstract_Wallet):
                 self.accounts[k] = BIP32_Account_2of2(v)
             elif v.get('xpub'):
                 self.accounts[k] = BIP32_Account(v)
+            elif v.get('pending'):
+                self.accounts[k] = PendingAccount(v)
             else:
-                raise
+                print_error("cannot load account", v)
 
-        self.pending_accounts = self.storage.get('pending_accounts',{})
 
+    def account_is_pending(self, k):
+        return type(self.accounts.get(k)) == PendingAccount
 
     def delete_pending_account(self, k):
-        self.pending_accounts.pop(k)
-        self.storage.put('pending_accounts', self.pending_accounts)
-
-    def account_is_pending(self, k):
-        return k in self.pending_accounts
+        assert self.account_is_pending(k)
+        self.accounts.pop(k)
+        self.save_accounts()
 
     def create_pending_account(self, name, password):
         account_id, addr = self.next_account_address(password)
         self.set_label(account_id, name)
-        self.pending_accounts[account_id] = addr
-        self.storage.put('pending_accounts', self.pending_accounts)
+        self.accounts[account_id] = PendingAccount({'pending':addr})
+        self.save_accounts()
 
-    def get_pending_accounts(self):
-        return self.pending_accounts.items()
+    def get_accounts(self):
+        out = sorted(self.accounts.items())
+        if self.imported_keys:
+            out.append( (-1, self.imported_account ))
+        return dict(out)
 
 
 
@@ -1383,22 +1411,6 @@ class NewWallet(Deterministic_Wallet):
         xpriv = pw_decode( k, password)
         return xpriv
 
-    def add_seed(self, seed, password):
-        if self.seed: 
-            raise Exception("a seed exists")
-        
-        self.seed_version, self.seed = self.prepare_seed(seed)
-        if password: 
-            self.seed = pw_encode( self.seed, password)
-            self.use_encryption = True
-        else:
-            self.use_encryption = False
-
-        self.storage.put('seed', self.seed, True)
-        self.storage.put('seed_version', self.seed_version, True)
-        self.storage.put('use_encryption', self.use_encryption,True)
-        self.create_master_keys(password)
-
 
     def create_watching_only_wallet(self, xpub):
         self.storage.put('seed_version', self.seed_version, True)
@@ -1647,8 +1659,10 @@ class OldWallet(Deterministic_Wallet):
 
 
     def get_account_name(self, k):
-        assert k == 0
-        return 'Main account'
+        if k == 0:
+            return 'Main account' 
+        elif k == -1:
+            return 'Imported'
 
 
     def get_private_key(self, address, password):