def get_account_addresses(self, a, include_change=True):
if a is None:
- o = self.addresses(True)
+ o = self.addresses(include_change)
elif a in self.accounts:
ac = self.accounts[a]
o = ac.get_addresses(0)
if n > nmax: nmax = n
return nmax + 1
+ def create_new_address(self, account, for_change):
+ if account is None:
+ account = self.default_account()
+ address = account.create_new_address(for_change)
+ self.history[address] = []
+ self.synchronizer.add(address)
+ self.save_accounts()
+ return address
+
def synchronize_sequence(self, account, for_change):
limit = self.gap_limit_for_change if for_change else self.gap_limit
- new_addresses = []
while True:
addresses = account.get_addresses(for_change)
if len(addresses) < limit:
- address = account.create_new_address(for_change)
- self.history[address] = []
- new_addresses.append( address )
+ self.create_new_address(account, for_change)
continue
-
if map( lambda a: self.address_is_old(a), addresses[-limit:] ) == limit*[False]:
break
else:
- address = account.create_new_address(for_change)
- self.history[address] = []
- new_addresses.append( address )
-
- return new_addresses
+ self.create_new_address(account, for_change)
def check_pending_accounts(self):
for account_id, addr in self.next_addresses.items():
self.next_addresses.pop(account_id)
def synchronize_account(self, account):
- new = []
- new += self.synchronize_sequence(account, 0)
- new += self.synchronize_sequence(account, 1)
- return new
+ self.synchronize_sequence(account, 0)
+ self.synchronize_sequence(account, 1)
def synchronize(self):
self.check_pending_accounts()
- new = []
for account in self.accounts.values():
if type(account) in [ImportedAccount, PendingAccount]:
continue
- new += self.synchronize_account(account)
- if new:
- self.save_accounts()
- self.storage.put('addr_history', self.history, True)
- return new
+ self.synchronize_account(account)
def restore(self, callback):
from i18n import _
def __init__(self, storage):
Deterministic_Wallet.__init__(self, storage)
+ def default_account(self):
+ return self.accounts["m/0'"]
+
def is_watching_only(self):
return self.master_private_keys is {}
NewWallet.__init__(self, storage)
self.storage.put('wallet_type', '2of2', True)
+ def default_account(self):
+ return self.accounts['m/']
+
def can_create_accounts(self):
return False
class OldWallet(Deterministic_Wallet):
+ def default_account(self):
+ return self.accounts[0]
+
def make_seed(self):
import mnemonic
seed = random_seed(128)