import aes
import Queue
import time
+import math
from util import print_msg, print_error, format_satoshis
from bitcoin import *
from transaction import Transaction
from plugins import run_hook
+COINBASE_MATURITY = 100
+DUST_THRESHOLD = 5430
+
# AES encryption
EncodeAES = lambda secret, s: base64.b64encode(aes.encryptData(secret,s))
DecodeAES = lambda secret, e: aes.decryptData(secret, base64.b64decode(e))
secret = Hash(password)
try:
d = DecodeAES(secret, s)
- except:
- raise BaseException('Invalid password')
+ except Exception:
+ raise Exception('Invalid password')
return d
else:
return s
-from version import ELECTRUM_VERSION, SEED_VERSION
+from version import *
class WalletStorage:
def __init__(self, config):
self.lock = threading.Lock()
+ self.config = config
self.data = {}
self.file_exists = False
- self.init_path(config)
+ self.path = self.init_path(config)
print_error( "wallet path", self.path )
if self.path:
self.read(self.path)
def init_path(self, config):
"""Set the path of the wallet."""
+ # command line -w option
path = config.get('wallet_path')
- if not path:
- path = config.get('default_wallet_path')
- if path is not None:
- self.path = path
- return
+ if path:
+ return path
+
+ # path in config file
+ path = config.get('default_wallet_path')
+ if path:
+ return path
+
+ # default path
+ dirpath = os.path.join(config.path, "wallets")
+ if not os.path.exists(dirpath):
+ os.mkdir(dirpath)
+
+ new_path = os.path.join(config.path, "wallets", "default_wallet")
+
+ # default path in pre 1.9 versions
+ old_path = os.path.join(config.path, "electrum.dat")
+ if os.path.exists(old_path) and not os.path.exists(new_path):
+ os.rename(old_path, new_path)
- self.path = os.path.join(config.path, "electrum.dat")
+ return new_path
def read(self, path):
return
try:
d = ast.literal_eval( data ) #parse raw data from reading wallet file
- except:
+ except Exception:
raise IOError("Cannot read wallet file.")
self.data = d
def get(self, key, default=None):
- return self.data.get(key, default)
+ v = self.data.get(key)
+ if v is None:
+ v = default
+ return v
def put(self, key, value, save = True):
if value is not None:
self.data[key] = value
else:
- self.data.pop[key]
+ self.data.pop(key)
if save:
self.write()
f = open(self.path,"w")
f.write( s )
f.close()
- if self.get('gui') != 'android':
+ if 'ANDROID_DATA' not in os.environ:
import stat
os.chmod(self.path,stat.S_IREAD | stat.S_IWRITE)
-class Wallet:
+
+
+
+class NewWallet:
def __init__(self, storage):
self.gap_limit_for_change = 3 # constant
# saved fields
- self.seed_version = storage.get('seed_version', SEED_VERSION)
+ self.seed_version = storage.get('seed_version', NEW_SEED_VERSION)
self.gap_limit = storage.get('gap_limit', 5)
self.use_change = storage.get('use_change',True)
self.seed = storage.get('seed', '') # encrypted
self.labels = storage.get('labels', {})
self.frozen_addresses = storage.get('frozen_addresses',[])
- self.prioritized_addresses = storage.get('prioritized_addresses',[])
self.addressbook = storage.get('contacts', [])
self.imported_keys = storage.get('imported_keys',{})
self.next_addresses = storage.get('next_addresses',{})
- if self.seed_version < 4:
- raise ValueError("This wallet seed is deprecated.")
+
+ # This attribute is set when wallet.start_threads is called.
+ self.synchronizer = None
self.load_accounts()
for k,v in tx_list.items():
try:
tx = Transaction(v)
- except:
+ except Exception:
print_msg("Warning: Cannot deserialize transactions. skipping")
continue
def import_key(self, sec, password):
# check password
- seed = self.decode_seed(password)
+ seed = self.get_seed(password)
try:
address = address_from_private_key(sec)
- except:
- raise BaseException('Invalid private key')
+ except Exception:
+ raise Exception('Invalid private key')
if self.is_mine(address):
- raise BaseException('Address already in wallet')
+ raise Exception('Address already in wallet')
# store the originally requested keypair into the imported keys table
self.imported_keys[address] = pw_encode(sec, password )
self.storage.put('imported_keys', self.imported_keys, True)
+ def make_seed(self):
+ import mnemonic, ecdsa
+ entropy = ecdsa.util.randrange( pow(2,160) )
+ nonce = 0
+ while True:
+ ss = "%040x"%(entropy+nonce)
+ s = hashlib.sha256(ss.decode('hex')).digest().encode('hex')
+ # we keep only 13 words, that's approximately 139 bits of entropy
+ words = mnemonic.mn_encode(s)[0:13]
+ seed = ' '.join(words)
+ if is_new_seed(seed):
+ break # this will remove 8 bits of entropy
+ nonce += 1
+
+ return seed
+
+
def init_seed(self, seed):
- if self.seed: raise BaseException("a seed exists")
- if not seed:
- seed = random_seed(128)
- self.seed = seed
+ import mnemonic, unicodedata
+
+ if self.seed:
+ raise Exception("a seed exists")
+
+ self.seed_version = NEW_SEED_VERSION
+ if not seed:
+ self.seed = self.make_seed()
+ return
+
+ self.seed = unicodedata.normalize('NFC', unicode(seed.strip()))
+
+
- def save_seed(self):
+ def save_seed(self, password):
+ if password:
+ self.seed = pw_encode( self.seed, password)
+ self.use_encryption = True
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_accounts(password)
+
- def create_watching_only_wallet(self, c0, K0):
- cK0 = ""
- self.master_public_keys = {
- "m/0'/": (c0, K0, cK0),
- }
+ def create_watching_only_wallet(self, xpub):
+ self.master_public_keys = { "m/": xpub }
self.storage.put('master_public_keys', self.master_public_keys, True)
- self.create_account('1','Main account')
+ self.storage.put('seed_version', self.seed_version, True)
+ account = BIP32_Account({'xpub':xpub})
+ self.add_account("m/", account)
- def create_accounts(self):
+ def create_accounts(self, password):
+ seed = pw_decode(self.seed, password)
# create default account
- self.create_master_keys('1', self.seed)
- self.create_account('1','Main account')
-
-
- def create_master_keys(self, account_type, seed):
- master_k, master_c, master_K, master_cK = bip32_init(self.seed)
- if account_type == '1':
- k0, c0, K0, cK0 = bip32_private_derivation(master_k, master_c, "m/", "m/0'/")
- self.master_public_keys["m/0'/"] = (c0, K0, cK0)
- self.master_private_keys["m/0'/"] = k0
- elif account_type == '2of2':
- k1, c1, K1, cK1 = bip32_private_derivation(master_k, master_c, "m/", "m/1'/")
- k2, c2, K2, cK2 = bip32_private_derivation(master_k, master_c, "m/", "m/2'/")
- self.master_public_keys["m/1'/"] = (c1, K1, cK1)
- self.master_public_keys["m/2'/"] = (c2, K2, cK2)
- self.master_private_keys["m/1'/"] = k1
- self.master_private_keys["m/2'/"] = k2
- elif account_type == '2of3':
- k3, c3, K3, cK3 = bip32_private_derivation(master_k, master_c, "m/", "m/3'/")
- k4, c4, K4, cK4 = bip32_private_derivation(master_k, master_c, "m/", "m/4'/")
- k5, c5, K5, cK5 = bip32_private_derivation(master_k, master_c, "m/", "m/5'/")
- self.master_public_keys["m/3'/"] = (c3, K3, cK3)
- self.master_public_keys["m/4'/"] = (c4, K4, cK4)
- self.master_public_keys["m/5'/"] = (c5, K5, cK5)
- self.master_private_keys["m/3'/"] = k3
- self.master_private_keys["m/4'/"] = k4
- self.master_private_keys["m/5'/"] = k5
+ self.create_master_keys(password)
+ self.create_account('Main account', password)
+
+ def create_master_keys(self, password):
+ xpriv, xpub = bip32_root(self.get_seed(password))
+ self.master_public_keys["m/"] = xpub
+ self.master_private_keys["m/"] = pw_encode(xpriv, password)
self.storage.put('master_public_keys', self.master_public_keys, True)
self.storage.put('master_private_keys', self.master_private_keys, True)
- def has_master_public_keys(self, account_type):
- if account_type == '1':
- return "m/0'/" in self.master_public_keys
- elif account_type == '2of2':
- return set(["m/1'/", "m/2'/"]) <= set(self.master_public_keys.keys())
- elif account_type == '2of3':
- return set(["m/3'/", "m/4'/", "m/5'/"]) <= set(self.master_public_keys.keys())
- def find_root_by_master_key(self, c, K):
- for key, v in self.master_public_keys.items():
+ def find_root_by_master_key(self, xpub):
+ for key, xpub2 in self.master_public_keys.items():
if key == "m/":continue
- cc, KK, _ = v
- if (c == cc) and (K == KK):
+ if xpub == xpub2:
return key
- def deseed_root(self, seed, password):
- # for safety, we ask the user to enter their seed
- assert seed == self.decode_seed(password)
- self.seed = ''
- self.storage.put('seed', '', True)
-
-
- def deseed_branch(self, k):
- # check that parent has no seed
- assert self.seed == ''
- self.master_private_keys.pop(k)
- self.storage.put('master_private_keys', self.master_private_keys, True)
-
def is_watching_only(self):
return (self.seed == '') and (self.master_private_keys == {})
-
- def account_id(self, account_type, i):
- if account_type == '1':
- return "m/0'/%d"%i
- elif account_type == '2of2':
- return "m/1'/%d & m/2'/%d"%(i,i)
- elif account_type == '2of3':
- return "m/3'/%d & m/4'/%d & m/5'/%d"%(i,i,i)
- else:
- raise BaseException('unknown account type')
-
-
- def num_accounts(self, account_type):
+ def num_accounts(self, account_type = '1of1'):
keys = self.accounts.keys()
i = 0
while True:
return i
- def new_account_address(self, account_type = '1'):
+ def next_account_address(self, account_type, password):
i = self.num_accounts(account_type)
- k = self.account_id(account_type,i)
+ account_id = self.account_id(account_type, i)
- addr = self.next_addresses.get(k)
+ addr = self.next_addresses.get(account_id)
if not addr:
- account_id, account = self.next_account(account_type)
+ account = self.make_account(account_id, password)
addr = account.first_address()
- self.next_addresses[k] = addr
- self.storage.put('next_addresses',self.next_addresses)
-
- return addr
-
-
- def next_account(self, account_type = '1'):
+ self.next_addresses[account_id] = addr
+ self.storage.put('next_addresses', self.next_addresses)
- i = self.num_accounts(account_type)
- account_id = self.account_id(account_type,i)
-
- if account_type is '1':
- master_c0, master_K0, _ = self.master_public_keys["m/0'/"]
- c0, K0, cK0 = bip32_public_derivation(master_c0.decode('hex'), master_K0.decode('hex'), "m/0'/", "m/0'/%d"%i)
- account = BIP32_Account({ 'c':c0, 'K':K0, 'cK':cK0 })
-
- elif account_type == '2of2':
- master_c1, master_K1, _ = self.master_public_keys["m/1'/"]
- c1, K1, cK1 = bip32_public_derivation(master_c1.decode('hex'), master_K1.decode('hex'), "m/1'/", "m/1'/%d"%i)
- master_c2, master_K2, _ = self.master_public_keys["m/2'/"]
- c2, K2, cK2 = bip32_public_derivation(master_c2.decode('hex'), master_K2.decode('hex'), "m/2'/", "m/2'/%d"%i)
- account = BIP32_Account_2of2({ 'c':c1, 'K':K1, 'cK':cK1, 'c2':c2, 'K2':K2, 'cK2':cK2 })
-
- elif account_type == '2of3':
- master_c3, master_K3, _ = self.master_public_keys["m/3'/"]
- c3, K3, cK3 = bip32_public_derivation(master_c3.decode('hex'), master_K3.decode('hex'), "m/3'/", "m/3'/%d"%i)
- master_c4, master_K4, _ = self.master_public_keys["m/4'/"]
- c4, K4, cK4 = bip32_public_derivation(master_c4.decode('hex'), master_K4.decode('hex'), "m/4'/", "m/4'/%d"%i)
- master_c5, master_K5, _ = self.master_public_keys["m/5'/"]
- c5, K5, cK5 = bip32_public_derivation(master_c5.decode('hex'), master_K5.decode('hex'), "m/5'/", "m/5'/%d"%i)
- account = BIP32_Account_2of3({ 'c':c3, 'K':K3, 'cK':cK3, 'c2':c4, 'K2':K4, 'cK2':cK4, 'c3':c5, 'K3':K5, 'cK3':cK5 })
+ return account_id, addr
- return account_id, account
+ def account_id(self, account_type, i):
+ if account_type == '1of1':
+ return "m/%d'"%i
+ else:
+ raise
+
+ def make_account(self, account_id, password):
+ """Creates and saves the master keys, but does not save the account"""
+ master_xpriv = pw_decode( self.master_private_keys["m/"] , password )
+ xpriv, xpub = bip32_private_derivation(master_xpriv, "m/", account_id)
+ self.master_private_keys[account_id] = pw_encode(xpriv, password)
+ self.master_public_keys[account_id] = xpub
+ self.storage.put('master_public_keys', self.master_public_keys, True)
+ self.storage.put('master_private_keys', self.master_private_keys, True)
+ account = BIP32_Account({'xpub':xpub})
+ return account
def set_label(self, name, text = None):
return changed
-
- def create_account(self, account_type = '1', name = None):
- account_id, account = self.next_account(account_type)
- self.accounts[account_id] = account
- self.save_accounts()
+ def create_account(self, name, password):
+ i = self.num_accounts('1of1')
+ account_id = self.account_id('1of1', i)
+ account = self.make_account(account_id, password)
+ self.add_account(account_id, account)
if name:
self.set_label(account_id, name)
+ # add address of the next account
+ _, _ = self.next_account_address('1of1', password)
- def create_old_account(self):
- mpk = OldAccount.mpk_from_seed(self.seed)
- self.storage.put('master_public_key', mpk, True)
- self.accounts[0] = OldAccount({'mpk':mpk, 0:[], 1:[]})
+
+ 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()
if k == 0:
v['mpk'] = self.storage.get('master_public_key')
self.accounts[k] = OldAccount(v)
- elif '&' in k:
+ elif v.get('xpub3'):
+ self.accounts[k] = BIP32_Account_2of3(v)
+ elif v.get('xpub2'):
self.accounts[k] = BIP32_Account_2of2(v)
- else:
+ elif v.get('xpub'):
self.accounts[k] = BIP32_Account(v)
+ else:
+ raise
+
+ self.pending_accounts = self.storage.get('pending_accounts',{})
+
+
+ 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
+ def create_pending_account(self, acct_type, name, password):
+ account_id, addr = self.next_account_address(acct_type, password)
+ self.set_label(account_id, name)
+ self.pending_accounts[account_id] = addr
+ self.storage.put('pending_accounts', self.pending_accounts)
- def addresses(self, include_change = True, next=False):
+ def get_pending_accounts(self):
+ return self.pending_accounts.items()
+
+
+ def addresses(self, include_change = True, _next=True):
o = self.get_account_addresses(-1, include_change)
for a in self.accounts.keys():
o += self.get_account_addresses(a, include_change)
- if next:
+ if _next:
for addr in self.next_addresses.values():
if addr not in o:
o += [addr]
return s[0] == 1
def get_master_public_key(self):
- if self.seed_version == 4:
- return self.storage.get("master_public_key")
- else:
- c, K, cK = self.storage.get("master_public_keys")["m/0'/"]
- return repr((c, K))
+ return self.storage.get("master_public_keys")["m/"]
def get_master_private_key(self, account, password):
- master_k = pw_decode( self.master_private_keys[account], password)
- master_c, master_K, master_Kc = self.master_public_keys[account]
- try:
- K, Kc = get_pubkeys_from_secret(master_k.decode('hex'))
- assert K.encode('hex') == master_K
- except:
- raise BaseException("Invalid password")
- return master_k
+ k = self.master_private_keys.get(account)
+ if not k: return
+ xpriv = pw_decode( k, password)
+ return xpriv
def get_address_index(self, address):
if address == addr:
return account, (for_change, addresses.index(addr))
- raise BaseException("Address not found", address)
+ for k,v in self.next_addresses.items():
+ if v == address:
+ return k, (0,0)
+
+ raise Exception("Address not found", address)
+
+
+ def getpubkeys(self, addr):
+ assert is_valid(addr) and self.is_mine(addr)
+ account, sequence = self.get_address_index(addr)
+ if account != -1:
+ a = self.accounts[account]
+ return a.get_pubkeys( sequence )
def get_roots(self, account):
roots = []
for a in account.split('&'):
s = a.strip()
- m = re.match("(m/\d+'/)(\d+)", s)
+ m = re.match("m/(\d+')", s)
roots.append( m.group(1) )
return roots
+
def is_seeded(self, account):
- if type(account) is int:
- return self.seed is not None
+ return True
+
for root in self.get_roots(account):
if root not in self.master_private_keys.keys():
return True
def rebase_sequence(self, account, sequence):
+ # account has one or more xpub
+ # sequence is a sequence of public derivations
c, i = sequence
dd = []
for a in account.split('&'):
s = a.strip()
- m = re.match("(m/\d+'/)(\d+)", s)
- root = m.group(1)
- num = int(m.group(2))
+ m = re.match("m/(\d+)'", s)
+ root = "m/"
+ num = int(m.group(1))
dd.append( (root, [num,c,i] ) )
return dd
- def get_keyID(self, account, sequence):
- if account == 0:
- return 'old'
-
- rs = self.rebase_sequence(account, sequence)
- dd = []
- for root, public_sequence in rs:
- c, K, _ = self.master_public_keys[root]
- s = '/' + '/'.join( map(lambda x:str(x), public_sequence) )
- dd.append( 'bip32(%s,%s,%s)'%(c,K, s) )
- return '&'.join(dd)
- def decode_seed(self, password):
- seed = pw_decode(self.seed, password)
- #todo: #self.sequences[0].check_seed(seed)
+ def get_seed(self, password):
+ s = pw_decode(self.seed, password)
+ seed = mnemonic_to_seed(s,'').encode('hex')
return seed
+
+
+ def get_mnemonic(self, password):
+ return pw_decode(self.seed, password)
def get_private_key(self, address, password):
+ if self.is_watching_only():
+ return []
+
+ # first check the provided password
+ seed = self.get_seed(password)
+
out = []
if address in self.imported_keys.keys():
out.append( pw_decode( self.imported_keys[address], password ) )
else:
- account, sequence = self.get_address_index(address)
- if account == 0:
- seed = self.decode_seed(password)
- pk = self.accounts[account].get_private_key(seed, sequence)
- out.append(pk)
- return out
-
- # assert address == self.accounts[account].get_address(*sequence)
- rs = self.rebase_sequence( account, sequence)
- for root, public_sequence in rs:
-
- if root not in self.master_private_keys.keys(): continue
- master_k = self.get_master_private_key(root, password)
- master_c, _, _ = self.master_public_keys[root]
- pk = bip32_private_key( public_sequence, master_k.decode('hex'), master_c.decode('hex'))
+ account_id, sequence = self.get_address_index(address)
+ account = self.accounts[account_id]
+ xpubs = account.get_master_pubkeys()
+ roots = [k for k, v in self.master_public_keys.iteritems() if v in xpubs]
+ for root in roots:
+ xpriv = self.get_master_private_key(root, password)
+ if not xpriv:
+ continue
+ _, _, _, c, k = deserialize_xkey(xpriv)
+ pk = bip32_private_key( sequence, k, c )
out.append(pk)
return out
+ def get_public_keys(self, address):
+ account_id, sequence = self.get_address_index(address)
+ return self.accounts[account_id].get_pubkeys(sequence)
+
+
def add_keypairs_from_wallet(self, tx, keypairs, password):
for txin in tx.inputs:
address = txin['address']
+ if not self.is_mine(address):
+ continue
private_keys = self.get_private_key(address, password)
for sec in private_keys:
pubkey = public_key_from_private_key(sec)
keypairs[ pubkey ] = sec
+ if address in self.imported_keys.keys():
+ txin['redeemPubkey'] = pubkey
def add_keypairs_from_KeyID(self, tx, keypairs, password):
+ # first check the provided password
+ seed = self.get_seed(password)
+
for txin in tx.inputs:
keyid = txin.get('KeyID')
if keyid:
roots = []
for s in keyid.split('&'):
- m = re.match("bip32\(([0-9a-f]+),([0-9a-f]+),(/\d+/\d+/\d+)", s)
+ m = re.match("bip32\((.*),(/\d+/\d+)\)", s)
if not m: continue
- c = m.group(1)
- K = m.group(2)
- sequence = m.group(3)
- root = self.find_root_by_master_key(c,K)
+ xpub = m.group(1)
+ sequence = m.group(2)
+ root = self.find_root_by_master_key(xpub)
if not root: continue
sequence = map(lambda x:int(x), sequence.strip('/').split('/'))
root = root + '%d'%sequence[0]
def signrawtransaction(self, tx, input_info, private_keys, password):
# check that the password is correct
- seed = self.decode_seed(password)
+ seed = self.get_seed(password)
# add input info
tx.add_input_info(input_info)
# add redeem script for coins that are in the wallet
# FIXME: add redeemPubkey too!
- unspent_coins = self.get_unspent_coins()
+
+ try:
+ unspent_coins = self.get_unspent_coins()
+ except:
+ # an exception may be raised is the wallet is not synchronized
+ unspent_coins = []
+
for txin in tx.inputs:
for item in unspent_coins:
if txin['prevout_hash'] == item['prevout_hash'] and txin['prevout_n'] == item['prevout_n']:
# add private keys from wallet
self.add_keypairs_from_wallet(tx, keypairs, password)
- self.sign_transaction(tx, keypairs)
+ self.sign_transaction(tx, keypairs, password)
def sign_message(self, address, message, password):
compressed = is_compressed(sec)
return key.sign_message(message, compressed, address)
- def verify_message(self, address, signature, message):
- try:
- EC_KEY.verify_message(address, signature, message)
- return True
- except BaseException as e:
- print_error("Verification error: {0}".format(e))
- return False
+
+
+ def decrypt_message(self, pubkey, message, password):
+ address = public_key_to_bc_address(pubkey.decode('hex'))
+ keys = self.get_private_key(address, password)
+ secret = keys[0]
+ ec = regenerate_key(secret)
+ decrypted = ec.decrypt_message(message)
+ return decrypted[0]
def change_gap_limit(self, value):
for tx_hash, tx_height in h:
if tx_height == 0:
tx_age = 0
- else:
- tx_age = self.verifier.blockchain.height - tx_height + 1
+ else:
+ tx_age = self.network.get_local_height() - tx_height + 1
if tx_age > age:
age = tx_age
return age > 2
return new_addresses
-
- def create_pending_accounts(self):
- for account_type in ['1','2of2','2of3']:
- if not self.has_master_public_keys(account_type):
- continue
- a = self.new_account_address(account_type)
- if self.address_is_old(a):
- print_error( "creating account", a )
- self.create_account(account_type)
+ def check_pending_accounts(self):
+ for account_id, addr in self.next_addresses.items():
+ if self.address_is_old(addr):
+ print_error( "creating account", account_id )
+ xpub = self.master_public_keys[account_id]
+ account = BIP32_Account({'xpub':xpub})
+ self.add_account(account_id, account)
+ self.next_addresses.pop(account_id)
def synchronize_account(self, account):
def synchronize(self):
- if self.master_public_keys:
- self.create_pending_accounts()
+ self.check_pending_accounts()
new = []
for account in self.accounts.values():
new += self.synchronize_account(account)
def get_address_flags(self, addr):
flags = "C" if self.is_change(addr) else "I" if addr in self.imported_keys.keys() else "-"
- flags += "F" if addr in self.frozen_addresses else "P" if addr in self.prioritized_addresses else "-"
+ flags += "F" if addr in self.frozen_addresses else "-"
return flags
def get_account_name(self, k):
- if k == 0:
- if self.seed_version == 4:
- name = 'Main account'
+ default = "Unnamed account"
+ m = re.match("m/0'/(\d+)", k)
+ if m:
+ num = m.group(1)
+ if num == '0':
+ default = "Main account"
else:
- name = 'Old account'
- else:
- default = "Unnamed account"
- m = re.match("m/0'/(\d+)", k)
- if m:
- num = m.group(1)
- if num == '0':
- default = "Main account"
- else:
- default = "Account %s"%num
+ default = "Account %s"%num
- m = re.match("m/1'/(\d+) & m/2'/(\d+)", k)
- if m:
- num = m.group(1)
- default = "2of2 account %s"%num
- name = self.labels.get(k, default)
-
+ m = re.match("m/1'/(\d+) & m/2'/(\d+)", k)
+ if m:
+ num = m.group(1)
+ default = "2of2 account %s"%num
+ name = self.labels.get(k, default)
return name
+
def get_account_names(self):
accounts = {}
for k, account in self.accounts.items():
accounts[-1] = 'Imported keys'
return accounts
+
def get_account_addresses(self, a, include_change=True):
if a is None:
o = self.addresses(True)
return o
def get_imported_balance(self):
- cc = uu = 0
- for addr in self.imported_keys.keys():
- c, u = self.get_addr_balance(addr)
- cc += c
- uu += u
- return cc, uu
+ return self.get_balance(self.imported_keys.keys())
def get_account_balance(self, account):
- if account is None:
- return self.get_balance()
- elif account == -1:
- return self.get_imported_balance()
-
- conf = unconf = 0
- for addr in self.get_account_addresses(account):
- c, u = self.get_addr_balance(addr)
- conf += c
- unconf += u
- return conf, unconf
+ return self.get_balance(self.get_account_addresses(account))
def get_frozen_balance(self):
- conf = unconf = 0
- for addr in self.frozen_addresses:
- c, u = self.get_addr_balance(addr)
- conf += c
- unconf += u
- return conf, unconf
-
+ return self.get_balance(self.frozen_addresses)
- def get_balance(self):
+ def get_balance(self, domain=None):
+ if domain is None: domain = self.addresses(True)
cc = uu = 0
- for a in self.accounts.keys():
- c, u = self.get_account_balance(a)
+ for addr in domain:
+ c, u = self.get_addr_balance(addr)
cc += c
uu += u
- c, u = self.get_imported_balance()
- cc += c
- uu += u
return cc, uu
if h == ['*']: continue
for tx_hash, tx_height in h:
tx = self.transactions.get(tx_hash)
- if tx is None: raise BaseException("Wallet not synchronized")
- for output in tx.d.get('outputs'):
+ if tx is None: raise Exception("Wallet not synchronized")
+ is_coinbase = tx.inputs[0].get('prevout_hash') == '0'*64
+ for o in tx.d.get('outputs'):
+ output = o.copy()
if output.get('address') != addr: continue
key = tx_hash + ":%d" % output.get('prevout_n')
if key in self.spent_outputs: continue
output['prevout_hash'] = tx_hash
output['height'] = tx_height
+ output['coinbase'] = is_coinbase
coins.append((tx_height, output))
# sort by age
return [x[1] for x in coins]
-
- def choose_tx_inputs( self, amount, fixed_fee, domain = None ):
+ def choose_tx_inputs( self, amount, fixed_fee, num_outputs, domain = None ):
""" todo: minimize tx size """
total = 0
fee = self.fee if fixed_fee is None else fixed_fee
if domain is None:
- domain = self.addresses()
+ domain = self.addresses(True)
for i in self.frozen_addresses:
if i in domain: domain.remove(i)
- prioritized = []
- for i in self.prioritized_addresses:
- if i in domain:
- domain.remove(i)
- prioritized.append(i)
-
coins = self.get_unspent_coins(domain)
- prioritized_coins = self.get_unspent_coins(prioritized)
-
inputs = []
- coins = prioritized_coins + coins
- for item in coins:
+ for item in coins:
+ if item.get('coinbase') and item.get('height') + COINBASE_MATURITY > self.network.get_local_height():
+ continue
addr = item.get('address')
v = item.get('value')
total += v
inputs.append(item)
- fee = self.estimated_fee(inputs) if fixed_fee is None else fixed_fee
+ fee = self.estimated_fee(inputs, num_outputs) if fixed_fee is None else fixed_fee
if total >= amount + fee: break
else:
inputs = []
self.fee = fee
self.storage.put('fee_per_kb', self.fee, True)
- def estimated_fee(self, inputs):
- estimated_size = len(inputs) * 180 + 80 # this assumes non-compressed keys
- fee = self.fee * int(round(estimated_size/1024.))
- if fee == 0: fee = self.fee
+ def estimated_fee(self, inputs, num_outputs):
+ estimated_size = len(inputs) * 180 + num_outputs * 34 # this assumes non-compressed keys
+ fee = self.fee * int(math.ceil(estimated_size/1000.))
return fee
def add_tx_change( self, inputs, outputs, amount, fee, total, change_addr=None):
"add change to a transaction"
change_amount = total - ( amount + fee )
- if change_amount != 0:
+ if change_amount > DUST_THRESHOLD:
if not change_addr:
# send change to one of the accounts involved in the tx
def receive_history_callback(self, addr, hist):
if not self.check_new_history(addr, hist):
- raise BaseException("error: received history for %s is not consistent with known transactions"%addr)
+ raise Exception("error: received history for %s is not consistent with known transactions"%addr)
with self.lock:
self.history[addr] = hist
def get_tx_history(self, account=None):
+ if not self.verifier:
+ return []
+
with self.transaction_lock:
history = self.transactions.items()
history.sort(key = lambda x: self.verifier.get_txpos(x[0]))
try:
default_label = self.labels[o_addr]
except KeyError:
- default_label = o_addr
+ default_label = '>' + o_addr
break
else:
default_label = '(internal)'
try:
default_label = self.labels[o_addr]
except KeyError:
- default_label = o_addr
+ default_label = '<' + o_addr
return default_label
def make_unsigned_transaction(self, outputs, fee=None, change_addr=None, domain=None ):
for address, x in outputs:
- assert is_valid(address)
+ assert is_valid(address), "Address " + address + " is invalid!"
amount = sum( map(lambda x:x[1], outputs) )
- inputs, total, fee = self.choose_tx_inputs( amount, fee, domain )
+ inputs, total, fee = self.choose_tx_inputs( amount, fee, len(outputs), domain )
if not inputs:
raise ValueError("Not enough funds")
self.add_input_info(inputs)
return Transaction.from_io(inputs, outputs)
- def mktx_from_account(self, outputs, password, fee=None, change_addr=None, account=None):
- domain = self.get_account_addresses(account) if account else None
- return self.mktx(outputs, password, fee, change_addr, domain)
-
-
def mktx(self, outputs, password, fee=None, change_addr=None, domain= None ):
tx = self.make_unsigned_transaction(outputs, fee, change_addr, domain)
keypairs = {}
self.add_keypairs_from_wallet(tx, keypairs, password)
- self.sign_transaction(tx, keypairs)
+ if keypairs:
+ self.sign_transaction(tx, keypairs, password)
return tx
def add_input_info(self, inputs):
for txin in inputs:
address = txin['address']
- account, sequence = self.get_address_index(address)
- txin['KeyID'] = self.get_keyID(account, sequence)
- redeemScript = self.accounts[account].redeem_script(sequence)
+ if address in self.imported_keys.keys():
+ continue
+ account_id, sequence = self.get_address_index(address)
+ account = self.accounts[account_id]
+ txin['KeyID'] = account.get_keyID(sequence)
+ redeemScript = account.redeem_script(sequence)
if redeemScript:
txin['redeemScript'] = redeemScript
else:
- txin['redeemPubkey'] = self.accounts[account].get_pubkey(*sequence)
+ txin['redeemPubkey'] = account.get_pubkey(*sequence)
- def sign_transaction(self, tx, keypairs):
+ def sign_transaction(self, tx, keypairs, password):
tx.sign(keypairs)
- run_hook('sign_transaction', tx)
+ run_hook('sign_transaction', tx, password)
def sendtx(self, tx):
# synchronous
h = self.send_tx(tx)
self.tx_event.wait()
- return self.receive_tx(h)
+ return self.receive_tx(h, tx)
def send_tx(self, tx):
# asynchronous
self.tx_result = r.get('result')
self.tx_event.set()
- def receive_tx(self,tx_hash):
+ def receive_tx(self, tx_hash, tx):
out = self.tx_result
if out != tx_hash:
return False, "error: " + out
+ run_hook('receive_tx', tx, self)
return True, out
- def update_password(self, seed, old_password, new_password):
+ def update_password(self, old_password, new_password):
if new_password == '': new_password = None
- # this will throw an exception if unicode cannot be converted
- self.seed = pw_encode( seed, new_password)
+ decoded = self.get_seed(old_password)
+ self.seed = pw_encode( decoded, new_password)
self.storage.put('seed', self.seed, True)
self.use_encryption = (new_password != None)
self.storage.put('use_encryption', self.use_encryption,True)
def freeze(self,addr):
if self.is_mine(addr) and addr not in self.frozen_addresses:
- self.unprioritize(addr)
self.frozen_addresses.append(addr)
self.storage.put('frozen_addresses', self.frozen_addresses, True)
return True
else:
return False
- def prioritize(self,addr):
- if self.is_mine(addr) and addr not in self.prioritized_addresses:
- self.unfreeze(addr)
- self.prioritized_addresses.append(addr)
- self.storage.put('prioritized_addresses', self.prioritized_addresses, True)
- return True
- else:
- return False
-
- def unprioritize(self,addr):
- if self.is_mine(addr) and addr in self.prioritized_addresses:
- self.prioritized_addresses.remove(addr)
- self.storage.put('prioritized_addresses', self.prioritized_addresses, True)
- return True
- else:
- return False
-
def set_verifier(self, verifier):
self.verifier = verifier
def start_threads(self, network):
from verifier import TxVerifier
self.network = network
- self.verifier = TxVerifier(self.network, self.storage)
- self.verifier.start()
- self.set_verifier(self.verifier)
- self.synchronizer = WalletSynchronizer(self)
- self.synchronizer.start()
+ if self.network is not None:
+ self.verifier = TxVerifier(self.network, self.storage)
+ self.verifier.start()
+ self.set_verifier(self.verifier)
+ self.synchronizer = WalletSynchronizer(self, network)
+ self.synchronizer.start()
+ else:
+ self.verifier = None
+ self.synchronizer =None
def stop_threads(self):
- self.verifier.stop()
- self.synchronizer.stop()
-
+ if self.network:
+ self.verifier.stop()
+ self.synchronizer.stop()
def restore(self, callback):
msg = "%s\n%s %d\n%s %.1f"%(
_("Please wait..."),
_("Addresses generated:"),
- len(self.addresses(True)),_("Kilobytes received:"),
+ len(self.addresses(True)),
+ _("Kilobytes received:"),
self.network.interface.bytes_received/1024.)
apply(callback, (msg,))
time.sleep(0.1)
def wait_for_network():
- while not self.network.interface.is_connected:
+ while not self.network.is_connected():
msg = "%s \n" % (_("Connecting..."))
apply(callback, (msg,))
time.sleep(0.1)
# wait until we are connected, because the user might have selected another server
- wait_for_network()
-
- # try to restore old account
- self.create_old_account()
- wait_for_wallet()
-
- if self.is_found():
- self.seed_version = 4
- self.storage.put('seed_version', wallet.seed_version, True)
- else:
- self.accounts.pop(0)
- self.create_accounts()
+ if self.network:
+ wait_for_network()
wait_for_wallet()
+ else:
+ self.synchronize()
+
+ self.fill_addressbook()
class WalletSynchronizer(threading.Thread):
- def __init__(self, wallet):
+ def __init__(self, wallet, network):
threading.Thread.__init__(self)
self.daemon = True
self.wallet = wallet
- wallet.synchronizer = self
- self.network = self.wallet.network
- #self.wallet.network.register_callback('connected', lambda: self.wallet.set_up_to_date(False))
+ self.network = network
self.was_updated = True
self.running = False
self.lock = threading.Lock()
self.running = True
while self.is_running():
- interface = self.network.interface
- if not interface.is_connected:
- print_error("synchronizer: waiting for interface")
- interface.connect_event.wait()
+
+ if not self.network.is_connected():
+ self.network.wait_until_connected()
- self.run_interface(interface)
+ self.run_interface()
- def run_interface(self, interface):
+ def run_interface(self):
- print_error("synchronizer: connected to", interface.server)
+ print_error("synchronizer: connected to", self.network.main_server())
requested_tx = []
missing_tx = []
print_error("missing tx", missing_tx)
# subscriptions
- self.subscribe_to_addresses(self.wallet.addresses(True, next=True))
+ self.subscribe_to_addresses(self.wallet.addresses(True))
while self.is_running():
# 1. create new addresses
# request missing transactions
for tx_hash, tx_height in missing_tx:
if (tx_hash, tx_height) not in requested_tx:
- interface.send([ ('blockchain.transaction.get',[tx_hash, tx_height]) ], lambda i,r: self.queue.put(r))
+ self.network.send([ ('blockchain.transaction.get',[tx_hash, tx_height]) ], lambda i,r: self.queue.put(r))
requested_tx.append( (tx_hash, tx_height) )
missing_tx = []
# detect if situation has changed
- if interface.is_up_to_date() and self.queue.empty():
+ if self.network.is_up_to_date() and self.queue.empty():
if not self.wallet.is_up_to_date():
self.wallet.set_up_to_date(True)
self.was_updated = True
self.was_updated = True
if self.was_updated:
- self.wallet.network.trigger_callback('updated')
+ self.network.trigger_callback('updated')
self.was_updated = False
# 2. get a response
except Queue.Empty:
continue
- if interface != self.network.interface:
- break
+ # see if it changed
+ #if interface != self.network.interface:
+ # break
if not r:
continue
addr = params[0]
if self.wallet.get_status(self.wallet.get_history(addr)) != result:
if requested_histories.get(addr) is None:
- interface.send([('blockchain.address.get_history', [addr])], lambda i,r:self.queue.put(r))
+ self.network.send([('blockchain.address.get_history', [addr])], lambda i,r:self.queue.put(r))
requested_histories[addr] = result
elif method == 'blockchain.address.get_history':
hist.append( (tx_hash, item['height']) )
if len(hist) != len(result):
- raise BaseException("error: server sent history with non-unique txid", result)
+ raise Exception("error: server sent history with non-unique txid", result)
# check that the status corresponds to what was announced
rs = requested_histories.pop(addr)
if self.wallet.get_status(hist) != rs:
- raise BaseException("error: status mismatch: %s"%addr)
+ raise Exception("error: status mismatch: %s"%addr)
# store received history
self.wallet.receive_history_callback(addr, hist)
print_error("Error: Unknown message:" + method + ", " + repr(params) + ", " + repr(result) )
if self.was_updated and not requested_tx:
- self.wallet.network.trigger_callback('updated')
- self.wallet.network.trigger_callback("new_transaction") # Updated gets called too many times from other places as well; if we use that signal we get the notification three times
-
+ self.network.trigger_callback('updated')
+ # Updated gets called too many times from other places as well; if we use that signal we get the notification three times
+ self.network.trigger_callback("new_transaction")
self.was_updated = False
+
+
+
+
+class OldWallet(NewWallet):
+
+ def init_seed(self, seed):
+ import mnemonic
+
+ if self.seed:
+ raise Exception("a seed exists")
+
+ if not seed:
+ seed = random_seed(128)
+
+ self.seed_version = OLD_SEED_VERSION
+
+ # see if seed was entered as hex
+ seed = seed.strip()
+ try:
+ assert seed
+ seed.decode('hex')
+ self.seed = str(seed)
+ return
+ except Exception:
+ pass
+
+ words = seed.split()
+ try:
+ mnemonic.mn_decode(words)
+ except Exception:
+ raise
+
+ self.seed = mnemonic.mn_decode(words)
+
+ if not self.seed:
+ raise Exception("Invalid seed")
+
+
+
+ def get_master_public_key(self):
+ return self.storage.get("master_public_key")
+
+ def create_accounts(self, password):
+ seed = pw_decode(self.seed, password)
+ mpk = OldAccount.mpk_from_seed(seed)
+ self.create_account(mpk)
+
+ def create_account(self, mpk):
+ self.storage.put('master_public_key', mpk, True)
+ self.accounts[0] = OldAccount({'mpk':mpk, 0:[], 1:[]})
+ self.save_accounts()
+
+ def create_watching_only_wallet(self, mpk):
+ self.seed_version = OLD_SEED_VERSION
+ self.storage.put('seed_version', self.seed_version, True)
+ self.create_account(mpk)
+
+ def get_seed(self, password):
+ seed = pw_decode(self.seed, password)
+ self.accounts[0].check_seed(seed)
+ return seed
+
+ def get_mnemonic(self, password):
+ import mnemonic
+ s = pw_decode(self.seed, password)
+ return ' '.join(mnemonic.mn_encode(s))
+
+
+ def add_keypairs_from_KeyID(self, tx, keypairs, password):
+ # first check the provided password
+ seed = self.get_seed(password)
+ for txin in tx.inputs:
+ keyid = txin.get('KeyID')
+ if keyid:
+ m = re.match("old\(([0-9a-f]+),(\d+),(\d+)", keyid)
+ if not m: continue
+ mpk = m.group(1)
+ if mpk != self.storage.get('master_public_key'): continue
+ for_change = int(m.group(2))
+ num = int(m.group(3))
+ account = self.accounts[0]
+ addr = account.get_address(for_change, num)
+ txin['address'] = addr # fixme: side effect
+ pk = account.get_private_key(seed, (for_change, num))
+ pubkey = public_key_from_private_key(pk)
+ keypairs[pubkey] = pk
+
+
+ def get_account_name(self, k):
+ assert k == 0
+ return 'Main account'
+
+ def is_seeded(self, account):
+ return self.seed is not None
+
+ def get_private_key(self, address, password):
+ if self.is_watching_only():
+ return []
+
+ # first check the provided password
+ seed = self.get_seed(password)
+
+ out = []
+ if address in self.imported_keys.keys():
+ out.append( pw_decode( self.imported_keys[address], password ) )
+ else:
+ account_id, sequence = self.get_address_index(address)
+ pk = self.accounts[0].get_private_key(seed, sequence)
+ out.append(pk)
+ return out
+
+ def check_pending_accounts(self):
+ pass
+
+
+# former WalletFactory
+class Wallet(object):
+
+ def __new__(self, storage):
+ config = storage.config
+ if config.get('bitkey', False):
+ # if user requested support for Bitkey device,
+ # import Bitkey driver
+ from wallet_bitkey import WalletBitkey
+ return WalletBitkey(config)
+
+ if not storage.file_exists:
+ seed_version = NEW_SEED_VERSION if config.get('bip32') is True else OLD_SEED_VERSION
+ else:
+ seed_version = storage.get('seed_version')
+ if not seed_version:
+ seed_version = OLD_SEED_VERSION if len(storage.get('master_public_key')) == 128 else NEW_SEED_VERSION
+
+ if seed_version == OLD_SEED_VERSION:
+ return OldWallet(storage)
+ elif seed_version == NEW_SEED_VERSION:
+ return NewWallet(storage)
+ else:
+ msg = "This wallet seed is not supported."
+ if seed_version in [5]:
+ msg += "\nTo open this wallet, try 'git checkout seed_v%d'"%seed_version
+ print msg
+ sys.exit(1)
+
+
+
+ @classmethod
+ def is_seed(self, seed):
+ if not seed:
+ return False
+ elif is_old_seed(seed):
+ return OldWallet
+ elif is_new_seed(seed):
+ return NewWallet
+ else:
+ return False
+
+ @classmethod
+ def from_seed(self, seed, storage):
+ klass = self.is_seed(seed)
+ w = klass(storage)
+ w.init_seed(seed)
+ return w
+
+ @classmethod
+ def from_mpk(self, mpk, storage):
+
+ try:
+ int(mpk, 16)
+ old = True
+ except:
+ old = False
+
+ if old:
+ w = OldWallet(storage)
+ w.seed = ''
+ w.create_watching_only_wallet(mpk)
+ else:
+ w = NewWallet(storage)
+ w.create_watching_only_wallet(mpk)
+
+ return w
git://git.novaco.in / electrum-nvc.git / blobdiff