import bitcoin
from synchronizer import WalletSynchronizer
-COINBASE_MATURITY = 100
-DUST_THRESHOLD = 5430
+COINBASE_MATURITY = 500
+DUST_THRESHOLD = 1000
# internal ID for imported account
IMPORTED_ACCOUNT = '/x'
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")
+ old_path = os.path.join(config.path, "electrum-nvc.dat")
if os.path.exists(old_path) and not os.path.exists(new_path):
os.rename(old_path, new_path)
self.history = storage.get('addr_history',{}) # address -> list(txid, height)
- self.fee = int(storage.get('fee_per_kb', 10000))
+ self.fee = int(storage.get('fee_per_kb', 1000))
self.next_addresses = storage.get('next_addresses',{})
# This attribute is set when wallet.start_threads is called.
self.synchronizer = None
- self.load_accounts()
-
- self.transactions = {}
- tx_list = self.storage.get('transactions',{})
- for k, raw in tx_list.items():
- try:
- tx = Transaction.deserialize(raw)
- except Exception:
- print_msg("Warning: Cannot deserialize transactions. skipping")
- continue
+ # imported_keys is deprecated. The GUI should call convert_imported_keys
+ self.imported_keys = self.storage.get('imported_keys',{})
- self.add_pubkey_addresses(tx)
- self.transactions[k] = tx
+ self.load_accounts()
- for h,tx in self.transactions.items():
- if not self.check_new_tx(h, tx):
- print_error("removing unreferenced tx", h)
- self.transactions.pop(h)
+ self.load_transactions()
# not saved
self.prevout_values = {} # my own transaction outputs
self.spent_outputs = []
-
# spv
self.verifier = None
-
# there is a difference between wallet.up_to_date and interface.is_up_to_date()
# interface.is_up_to_date() returns true when all requests have been answered and processed
# wallet.up_to_date is true when the wallet is synchronized (stronger requirement)
-
self.up_to_date = False
self.lock = threading.Lock()
self.transaction_lock = threading.Lock()
for tx_hash, tx in self.transactions.items():
self.update_tx_outputs(tx_hash)
+ def load_transactions(self):
+ self.transactions = {}
+ tx_list = self.storage.get('transactions',{})
+ for k, raw in tx_list.items():
+ try:
+ tx = Transaction.deserialize(raw)
+ except Exception, e:
+ print_msg("Warning: Cannot deserialize transactions. skipping")
+ continue
+ self.add_pubkey_addresses(tx)
+ self.transactions[k] = tx
+ for h,tx in self.transactions.items():
+ if not self.check_new_tx(h, tx):
+ print_error("removing unreferenced tx", h)
+ self.transactions.pop(h)
+
def add_pubkey_addresses(self, tx):
# find the address corresponding to pay-to-pubkey inputs
h = tx.hash()
def load_accounts(self):
self.accounts = {}
- self.imported_keys = self.storage.get('imported_keys',{})
d = self.storage.get('accounts', {})
for k, v in d.items():
def get_public_keys(self, address):
account_id, sequence = self.get_address_index(address)
- return self.accounts[account_id].get_pubkeys(sequence)
+ return self.accounts[account_id].get_pubkeys(*sequence)
def add_keypairs(self, tx, keypairs, password):
# first check the provided password. This will raise if invalid.
def signrawtransaction(self, tx, private_keys, password):
# check that the password is correct. This will raise if it's not.
- self.get_seed(password)
-
+ self.check_password(password)
# build a list of public/private keys
keypairs = {}
-
# add private keys from parameter
for sec in private_keys:
pubkey = public_key_from_private_key(sec)
keypairs[ pubkey ] = sec
-
# add private_keys
self.add_keypairs(tx, keypairs, password)
-
# sign the transaction
self.sign_transaction(tx, keypairs, password)
if address in tx.get_output_addresses(): n += 1
return n
- 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 "-"
- return flags
-
def get_tx_value(self, tx, account=None):
domain = self.get_account_addresses(account)
return tx.get_value(domain, self.prevout_values)
def update_tx_outputs(self, tx_hash):
tx = self.transactions.get(tx_hash)
- for i, (addr, value) in enumerate(tx.get_outputs()):
+ for i, (type, addr, value) in enumerate(tx.get_outputs()):
key = tx_hash+ ':%d'%i
self.prevout_values[key] = value
tx = self.transactions.get(tx_hash)
if not tx: continue
- for i, (addr, value) in enumerate(tx.get_outputs()):
+ for i, (type, addr, value) in enumerate(tx.get_outputs()):
if addr == address:
key = tx_hash + ':%d'%i
received_coins.append(key)
if key in received_coins:
v -= value
- for i, (addr, value) in enumerate(tx.get_outputs()):
+ for i, (type, addr, value) in enumerate(tx.get_outputs()):
key = tx_hash + ':%d'%i
if addr == address:
v += value
for tx_hash, tx_height in h:
tx = self.transactions.get(tx_hash)
if tx is None: raise Exception("Wallet not synchronized")
+ outputs = tx.get_outputs()
+
is_coinbase = tx.inputs[0].get('prevout_hash') == '0'*64
- for i, (address, value) in enumerate(tx.get_outputs()):
+ is_coinstake = outputs[0][2] == 0
+
+ #print is_coinstake
+
+ for i, (type, address, value) in enumerate(outputs):
output = {'address':address, 'value':value, 'prevout_n':i}
if address != addr: continue
key = tx_hash + ":%d"%i
output['prevout_hash'] = tx_hash
output['height'] = tx_height
output['coinbase'] = is_coinbase
+ output['coinstake'] = is_coinstake
+ output["type"] = type
coins.append((tx_height, output))
# sort by age
inputs = []
for item in coins:
- if item.get('coinbase') and item.get('height') + COINBASE_MATURITY > self.network.get_local_height():
+ if (item.get('coinbase') or item.get('coinstake')) and item.get('height') + COINBASE_MATURITY > self.network.get_local_height():
continue
v = item.get('value')
total += v
for txin in inputs:
self.add_input_info(txin)
outputs = self.add_tx_change(inputs, outputs, amount, fee, total, change_addr)
- return Transaction(inputs, outputs)
+ return Transaction(int(time.time()), inputs, outputs)
def mktx(self, outputs, password, fee=None, change_addr=None, domain= None, coins = None ):
tx = self.make_unsigned_transaction(outputs, fee, change_addr, domain, coins)
imported_account.update_password(old_password, new_password)
self.save_accounts()
- for k, v in self.master_private_keys.items():
- b = pw_decode(v, old_password)
- c = pw_encode(b, new_password)
- self.master_private_keys[k] = c
- self.storage.put('master_private_keys', self.master_private_keys, True)
+ if hasattr(self, 'master_private_keys'):
+ for k, v in self.master_private_keys.items():
+ b = pw_decode(v, old_password)
+ c = pw_encode(b, new_password)
+ self.master_private_keys[k] = c
+ self.storage.put('master_private_keys', self.master_private_keys, True)
self.use_encryption = (new_password != None)
self.storage.put('use_encryption', self.use_encryption,True)
return True
return False
- def find_root_by_master_key(self, xpub):
- for key, xpub2 in self.master_public_keys.items():
- if key == "m/":continue
- if xpub == xpub2:
- return key
-
def num_accounts(self):
keys = []
for k, v in self.accounts.items():