from plugins import run_hook
COINBASE_MATURITY = 100
+DUST_THRESHOLD = 5430
# AES encryption
EncodeAES = lambda secret, s: base64.b64encode(aes.encryptData(secret,s))
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:
self.lock = threading.Lock()
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()
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.")
+ if self.seed_version not in [4, 6]:
+ msg = "This wallet seed is not supported."
+ if self.seed_version in [5]:
+ msg += "\nTo open this wallet, try 'git checkout seed_v%d'"%self.seed_version
+ print msg
+ sys.exit(1)
+
+ # 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 mnemonic_hash(seed).startswith(SEED_PREFIX):
+ break # this removes 12 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
+
+ if self.seed:
+ raise Exception("a seed exists")
+
+ if not seed:
+ self.seed = random_seed(128)
+ self.seed_version = 4
+ return
+
+ #if not seed:
+ # self.seed = self.make_seed()
+ # self.seed_version = SEED_VERSION
+ # return
+
+ # find out what kind of wallet we are
+ try:
+ seed.strip().decode('hex')
+ self.seed_version = 4
+ self.seed = str(seed)
+ return
+ except Exception:
+ pass
+ words = seed.split()
+ self.seed_version = 4
+ self.seed = mnemonic.mn_decode(words)
+
+ #try:
+ # mnemonic.mn_decode(words)
+ # uses_electrum_words = True
+ #except Exception:
+ # uses_electrum_words = False
+ #
+ #if uses_electrum_words and len(words) != 13:
+ # self.seed_version = 4
+ # self.seed = mnemonic.mn_decode(words)
+ #else:
+ # assert mnemonic_hash(seed).startswith(SEED_PREFIX)
+ # self.seed_version = SEED_VERSION
+ # self.seed = seed
+
- 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, params):
+ K0, c0 = params
+ if not K0:
+ return
+
+ if not c0:
+ self.seed_version = 4
+ self.storage.put('seed_version', self.seed_version, True)
+ self.create_old_account(K0)
+ return
- def create_watching_only_wallet(self, c0, K0):
cK0 = ""
self.master_public_keys = {
"m/0'/": (c0, K0, cK0),
}
self.storage.put('master_public_keys', self.master_public_keys, True)
+ self.storage.put('seed_version', self.seed_version, True)
self.create_account('1','Main account')
- def create_accounts(self):
- # create default account
- self.create_master_keys('1', self.seed)
- self.create_account('1','Main account')
+ def create_accounts(self, password):
+ seed = pw_decode(self.seed, password)
+
+ if self.seed_version == 4:
+ mpk = OldAccount.mpk_from_seed(seed)
+ self.create_old_account(mpk)
+ else:
+ # create default account
+ self.create_master_keys('1', password)
+ 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)
+ def create_master_keys(self, account_type, password):
+ master_k, master_c, master_K, master_cK = bip32_init(self.get_seed(None))
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
+ self.master_private_keys["m/0'/"] = pw_encode(k0, password)
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
+ self.master_private_keys["m/1'/"] = pw_encode(k1, password)
+ self.master_private_keys["m/2'/"] = pw_encode(k2, password)
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'/")
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.master_private_keys["m/3'/"] = pw_encode(k3, password)
+ self.master_private_keys["m/4'/"] = pw_encode(k4, password)
+ self.master_private_keys["m/5'/"] = pw_encode(k5, password)
self.storage.put('master_public_keys', self.master_public_keys, True)
self.storage.put('master_private_keys', self.master_private_keys, True)
def deseed_root(self, seed, password):
# for safety, we ask the user to enter their seed
- assert seed == self.decode_seed(password)
+ assert seed == self.get_seed(password)
self.seed = ''
self.storage.put('seed', '', True)
elif account_type == '2of3':
return "m/3'/%d & m/4'/%d & m/5'/%d"%(i,i,i)
else:
- raise BaseException('unknown account type')
+ raise Exception('unknown account type')
def num_accounts(self, account_type):
self.set_label(k, name)
- def create_old_account(self):
- mpk = OldAccount.mpk_from_seed(self.seed)
+ def create_old_account(self, mpk):
self.storage.put('master_public_key', mpk, True)
self.accounts[0] = OldAccount({'mpk':mpk, 0:[], 1:[]})
self.save_accounts()
try:
K, Kc = get_pubkeys_from_secret(master_k.decode('hex'))
assert K.encode('hex') == master_K
- except:
- raise BaseException("Invalid password")
+ except Exception:
+ raise Exception("Invalid password")
return master_k
if v == address:
return k, (0,0)
- raise BaseException("Address not found", address)
+ raise Exception("Address not found", address)
def get_roots(self, account):
def get_keyID(self, account, sequence):
if account == 0:
- return 'old'
+ a, b = sequence
+ mpk = self.storage.get('master_public_key')
+ return 'old(%s,%d,%d)'%(mpk,a,b)
rs = self.rebase_sequence(account, sequence)
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)
+ if self.seed_version == 4:
+ seed = s
+ self.accounts[0].check_seed(seed)
+ else:
+ seed = mnemonic_hash(s)
return seed
+ def get_mnemonic(self, password):
+ import mnemonic
+ s = pw_decode(self.seed, password)
+ if self.seed_version == 4:
+ return ' '.join(mnemonic.mn_encode(s))
+ else:
+ return s
+
+
+
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
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:
+
+ if self.seed_version == 4:
+ 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
+ continue
+
+
roots = []
for s in keyid.split('&'):
m = re.match("bip32\(([0-9a-f]+),([0-9a-f]+),(/\d+/\d+/\d+)", s)
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)
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
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")
+ if tx is None: raise Exception("Wallet not synchronized")
is_coinbase = tx.inputs[0].get('prevout_hash') == '0'*64
- for output in tx.d.get('outputs'):
+ 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
return [x[1] for x in coins]
-
- def choose_tx_inputs_from_account( self, amount, fixed_fee, account ):
- domain = self.get_account_addresses(account) if account else None
- return self.choose_tx_inputs( amount, fixed_fee, domain )
-
-
def choose_tx_inputs( self, amount, fixed_fee, domain = None ):
""" todo: minimize tx size """
total = 0
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:
if item.get('coinbase') and item.get('height') + COINBASE_MATURITY > self.network.blockchain.height:
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]))
return Transaction.from_io(inputs, outputs)
- def mktx_from_account(self, outputs, password, fee=None, account=None):
- domain = self.get_account_addresses(account) if account else None
- return self.mktx(outputs, password, fee, change_addr=None, domain=domain)
-
-
def mktx(self, outputs, password, fee=None, change_addr=None, domain= None ):
tx = self.make_unsigned_transaction(outputs, fee, change_addr, domain)
keypairs = {}
def add_input_info(self, inputs):
for txin in inputs:
address = txin['address']
+ if address in self.imported_keys.keys():
+ continue
account, sequence = self.get_address_index(address)
txin['KeyID'] = self.get_keyID(account, sequence)
redeemScript = self.accounts[account].redeem_script(sequence)
# 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, network)
- self.synchronizer.start()
+ if self.network:
+ 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()
self.running = True
while self.is_running():
-
+
if not self.network.is_connected():
- print_error("synchronizer: waiting for interface")
self.network.wait_until_connected()
self.run_interface(self.network.interface)
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)
git://git.novaco.in / electrum-nvc.git / blobdiff