BTCPrivate
/
electrum-bitcoinprivate
mirror of https://github.com/BTCPrivate/electrum-bitcoinprivate.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

new wallet structure: 

- store addresses instead of pubkeys
 - derive pubkeys only for serialization
 - fix #2024
This commit is contained in:
ThomasV 2017-02-22 08:47:17 +01:00
parent b1f27d7e84
commit ff39068867
4 changed files with 103 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
gui/qt/main_window.py
View File

@ -903,7 +903,8 @@ class ElectrumWindow(QMainWindow, MessageBoxMixin, PrintError):
def clear_receive_tab(self):
addr = self.wallet.get_receiving_address()
self.receive_address_e.setText(addr)
if addr:
self.receive_address_e.setText(addr)
self.receive_message_e.setText('')
self.receive_amount_e.setAmount(None)
self.expires_label.hide()

3
lib/keystore.py
View File

@ -586,6 +586,9 @@ def xpubkey_to_address(x_pubkey):
address = public_key_to_p2pkh(pubkey.decode('hex'))
return pubkey, address
def xpubkey_to_pubkey(x_pubkey):
pubkey, address = xpubkey_to_address(x_pubkey)
return pubkey
hw_keystores = {}

93
lib/transaction.py
View File

@ -42,7 +42,7 @@ import struct
import struct
import StringIO
import random
from keystore import xpubkey_to_address
from keystore import xpubkey_to_address, xpubkey_to_pubkey
NO_SIGNATURE = 'ff'
@ -364,7 +364,7 @@ def parse_scriptSig(d, bytes):
print_error("cannot find address in input script", bytes.encode('hex'))
return
x_pubkeys = map(lambda x: x[1].encode('hex'), dec2[1:-2])
pubkeys = [xpubkey_to_address(x)[0] for x in x_pubkeys]
pubkeys = [xpubkey_to_pubkey(x) for x in x_pubkeys]
redeemScript = multisig_script(pubkeys, m)
# write result in d
d['type'] = 'p2sh'
@ -531,10 +531,23 @@ class Transaction:
self.deserialize()
return self._outputs
@classmethod
def get_sorted_pubkeys(self, txin):
# sort pubkeys and x_pubkeys, using the order of pubkeys
x_pubkeys = txin['x_pubkeys']
pubkeys = txin.get('pubkeys')
if pubkeys is None:
pubkeys = [xpubkey_to_pubkey(x) for x in x_pubkeys]
pubkeys, x_pubkeys = zip(*sorted(zip(pubkeys, x_pubkeys)))
txin['pubkeys'] = pubkeys = list(pubkeys)
txin['x_pubkeys'] = x_pubkeys = list(x_pubkeys)
return pubkeys, x_pubkeys
def update_signatures(self, raw):
"""Add new signatures to a transaction"""
d = deserialize(raw)
for i, txin in enumerate(self.inputs()):
pubkeys, x_pubkeys = self.get_sorted_pubkeys(txin)
sigs1 = txin.get('signatures')
sigs2 = d['inputs'][i].get('signatures')
for sig in sigs2:
@ -545,7 +558,6 @@ class Transaction:
order = ecdsa.ecdsa.generator_secp256k1.order()
r, s = ecdsa.util.sigdecode_der(sig.decode('hex'), order)
sig_string = ecdsa.util.sigencode_string(r, s, order)
pubkeys = txin.get('pubkeys')
compressed = True
for recid in range(4):
public_key = MyVerifyingKey.from_signature(sig_string, recid, pre_hash, curve = SECP256k1)
@ -563,7 +575,8 @@ class Transaction:
def deserialize(self):
if self.raw is None:
self.raw = self.serialize()
return
#self.raw = self.serialize()
if self._inputs is not None:
return
d = deserialize(self.raw)
@ -595,20 +608,22 @@ class Transaction:
# if we have enough signatures, we use the actual pubkeys
# otherwise, use extended pubkeys (with bip32 derivation)
num_sig = txin.get('num_sig', 1)
x_signatures = txin['signatures']
signatures = filter(None, x_signatures)
is_complete = len(signatures) == num_sig
if estimate_size:
# we assume that signature will be 0x48 bytes long
pubkeys = txin['pubkeys']
pk_list = [ "00" * 0x21 ] * num_sig
sig_list = [ "00" * 0x48 ] * num_sig
elif is_complete:
pubkeys = txin['pubkeys']
sig_list = [(sig + '01') for sig in signatures]
else:
pubkeys = txin['x_pubkeys']
sig_list = [(sig + '01') if sig else NO_SIGNATURE for sig in x_signatures]
return pubkeys, sig_list
pubkeys, x_pubkeys = self.get_sorted_pubkeys(txin)
x_signatures = txin['signatures']
signatures = filter(None, x_signatures)
is_complete = len(signatures) == num_sig
if is_complete:
pk_list = pubkeys
sig_list = [(sig + '01') for sig in signatures]
else:
pk_list = x_pubkeys
sig_list = [(sig + '01') if sig else NO_SIGNATURE for sig in x_signatures]
return pk_list, sig_list
@classmethod
def serialize_witness(self, txin):
@ -622,24 +637,36 @@ class Transaction:
@classmethod
def input_script(self, txin, estimate_size=False):
redeem_script = txin.get('redeemScript')
if self.is_segwit_input(txin):
return push_script(redeem_script)
if txin['type'] == 'p2pk':
sig = txin['signatures'][0]
return push_script(sig)
_type = txin['type']
pubkeys, sig_list = self.get_siglist(txin, estimate_size)
script = ''.join(push_script(x) for x in sig_list)
if not pubkeys:
if _type == 'p2pk':
pass
elif redeem_script:
elif _type == 'p2sh':
# put op_0 before script
script = '00' + script
redeem_script = multisig_script(pubkeys, txin['num_sig'])
script += push_script(redeem_script)
else:
elif _type == 'p2pkh':
script += push_script(pubkeys[0])
elif _type == 'p2wpkh-p2sh':
redeem_script = segwit_script(pubkeys[0])
return push_script(redeem_script)
else:
raise TypeError('Unknown txin type', _type)
return script
@classmethod
def get_preimage_script(self, txin):
# only for non-segwit
if txin['type'] == 'p2pkh':
return get_scriptPubKey(txin['address'])
elif txin['type'] == 'p2sh':
pubkeys, x_pubkeys = self.get_sorted_pubkeys(txin)
return multisig_script(pubkeys, txin['num_sig'])
else:
raise TypeError('Unknown txin type', _type)
@classmethod
def serialize_outpoint(self, txin):
return txin['prevout_hash'].decode('hex')[::-1].encode('hex') + int_to_hex(txin['prevout_n'], 4)
@ -693,8 +720,7 @@ class Transaction:
nSequence = int_to_hex(txin.get('sequence', 0xffffffff), 4)
preimage = nVersion + hashPrevouts + hashSequence + outpoint + scriptCode + amount + nSequence + hashOutputs + nLocktime + nHashType
else:
txin_script = lambda txin: txin.get('redeemScript') or get_scriptPubKey(txin['address'])
txins = var_int(len(inputs)) + ''.join(self.serialize_input(txin, txin_script(txin) if i==k else '') for k, txin in enumerate(inputs))
txins = var_int(len(inputs)) + ''.join(self.serialize_input(txin, self.get_preimage_script(txin) if i==k else '') for k, txin in enumerate(inputs))
txouts = var_int(len(outputs)) + ''.join(self.serialize_output(o) for o in outputs)
preimage = nVersion + txins + txouts + nLocktime + nHashType
return preimage
@ -787,24 +813,19 @@ class Transaction:
def sign(self, keypairs):
for i, txin in enumerate(self.inputs()):
for i, txin in enumerate(self._inputs):
num = txin['num_sig']
for x_pubkey in txin['x_pubkeys']:
pubkeys, x_pubkeys = self.get_sorted_pubkeys(txin)
for j, x_pubkey in enumerate(x_pubkeys):
signatures = filter(None, txin['signatures'])
if len(signatures) == num:
# txin is complete
break
if x_pubkey in keypairs.keys():
print_error("adding signature for", x_pubkey)
# add pubkey to txin
txin = self._inputs[i]
x_pubkeys = txin['x_pubkeys']
ii = x_pubkeys.index(x_pubkey)
sec = keypairs[x_pubkey]
pubkey = public_key_from_private_key(sec)
txin['x_pubkeys'][ii] = pubkey
txin['pubkeys'][ii] = pubkey
self._inputs[i] = txin
assert pubkey == pubkeys[j]
# add signature
pre_hash = Hash(self.serialize_preimage(i).decode('hex'))
pkey = regenerate_key(sec)
@ -813,12 +834,12 @@ class Transaction:
public_key = private_key.get_verifying_key()
sig = private_key.sign_digest_deterministic(pre_hash, hashfunc=hashlib.sha256, sigencode = ecdsa.util.sigencode_der)
assert public_key.verify_digest(sig, pre_hash, sigdecode = ecdsa.util.sigdecode_der)
txin['signatures'][ii] = sig.encode('hex')
txin['signatures'][j] = sig.encode('hex')
txin['x_pubkeys'][j] = pubkey
self._inputs[i] = txin
print_error("is_complete", self.is_complete())
self.raw = self.serialize()
def get_outputs(self):
"""convert pubkeys to addresses"""
o = []

113
lib/wallet.py
View File

@ -209,15 +209,13 @@ class Abstract_Wallet(PrintError):
def basename(self):
return os.path.basename(self.storage.path)
def save_pubkeys(self):
self.storage.put('pubkeys', {'receiving':self.receiving_pubkeys, 'change':self.change_pubkeys})
def save_addresses(self):
self.storage.put('addresses', {'receiving':self.receiving_addresses, 'change':self.change_addresses})
def load_addresses(self):
d = self.storage.get('pubkeys', {})
self.receiving_pubkeys = d.get('receiving', [])
self.change_pubkeys = d.get('change', [])
self.receiving_addresses = map(self.pubkeys_to_address, self.receiving_pubkeys)
self.change_addresses = map(self.pubkeys_to_address, self.change_pubkeys)
d = self.storage.get('addresses', {})
self.receiving_addresses = d.get('receiving', [])
self.change_addresses = d.get('change', [])
def synchronize(self):
pass
@ -260,24 +258,15 @@ class Abstract_Wallet(PrintError):
def get_address_index(self, address):
if self.keystore.can_import():
i = self.receiving_addresses.index(address)
return self.receiving_pubkeys[i]
for pubkey in self.keystore.keypairs.keys():
if self.pubkeys_to_address(pubkey) == address:
return pubkey
elif address in self.receiving_addresses:
return False, self.receiving_addresses.index(address)
if address in self.change_addresses:
return True, self.change_addresses.index(address)
raise Exception("Address not found", address)
def get_pubkey_index(self, pubkey):
if self.keystore.can_import():
assert pubkey in self.receiving_pubkeys
return pubkey
elif pubkey in self.receiving_pubkeys:
return False, self.receiving_pubkeys.index(pubkey)
if pubkey in self.change_pubkeys:
return True, self.change_pubkeys.index(pubkey)
raise Exception("Pubkey not found", pubkey)
def get_private_key(self, address, password):
if self.is_watching_only():
return []
@ -287,8 +276,7 @@ class Abstract_Wallet(PrintError):
def get_public_key(self, address):
if self.keystore.can_import():
i = self.receiving_addresses.index(address)
pubkey = self.receiving_pubkeys[i]
pubkey = self.get_address_index(address)
else:
sequence = self.get_address_index(address)
pubkey = self.get_pubkey(*sequence)
@ -1063,6 +1051,7 @@ class Abstract_Wallet(PrintError):
return Transaction.from_io(inputs, outputs)
def add_input_info(self, txin):
txin['type'] = self.txin_type
# Add address for utxo that are in wallet
if txin.get('scriptSig') == '':
coins = self.get_spendable_coins()
@ -1137,6 +1126,8 @@ class Abstract_Wallet(PrintError):
def get_receiving_address(self):
# always return an address
domain = self.get_receiving_addresses()
if not domain:
return
choice = domain[0]
for addr in domain:
if not self.history.get(addr):
@ -1322,6 +1313,7 @@ class Imported_Wallet(Abstract_Wallet):
# wallet made of imported addresses
wallet_type = 'imported'
txin_type = 'unknown'
def __init__(self, storage):
Abstract_Wallet.__init__(self, storage)
@ -1397,11 +1389,9 @@ class Imported_Wallet(Abstract_Wallet):
def add_input_sig_info(self, txin, address):
addrtype, hash160 = bc_address_to_hash_160(address)
xpubkey = 'fd' + (chr(addrtype) + hash160).encode('hex')
txin['x_pubkeys'] = [ xpubkey ]
txin['pubkeys'] = [ xpubkey ]
x_pubkey = 'fd' + (chr(addrtype) + hash160).encode('hex')
txin['x_pubkeys'] = [x_pubkey]
txin['signatures'] = [None]
txin['type'] = 'unknown'
@ -1440,11 +1430,10 @@ class Deterministic_Wallet(Abstract_Wallet):
addresses = self.get_receiving_addresses()
k = self.num_unused_trailing_addresses(addresses)
n = len(addresses) - k + value
self.receiving_pubkeys = self.receiving_pubkeys[0:n]
self.receiving_addresses = self.receiving_addresses[0:n]
self.gap_limit = value
self.storage.put('gap_limit', self.gap_limit)
self.save_pubkeys()
self.save_addresses()
return True
else:
return False
@ -1471,14 +1460,12 @@ class Deterministic_Wallet(Abstract_Wallet):
return nmax + 1
def create_new_address(self, for_change):
pubkey_list = self.change_pubkeys if for_change else self.receiving_pubkeys
n = len(pubkey_list)
x = self.new_pubkeys(for_change, n)
pubkey_list.append(x)
self.save_pubkeys()
address = self.pubkeys_to_address(x)
addr_list = self.change_addresses if for_change else self.receiving_addresses
n = len(addr_list)
x = self.derive_pubkeys(for_change, n)
address = self.pubkeys_to_address(x)
addr_list.append(address)
self.save_addresses()
self.add_address(address)
return address
@ -1500,10 +1487,10 @@ class Deterministic_Wallet(Abstract_Wallet):
self.synchronize_sequence(False)
self.synchronize_sequence(True)
else:
if len(self.receiving_pubkeys) != len(self.keystore.keypairs):
self.receiving_pubkeys = self.keystore.keypairs.keys()
self.save_pubkeys()
self.receiving_addresses = map(self.pubkeys_to_address, self.receiving_pubkeys)
if len(self.receiving_addresses) != len(self.keystore.keypairs):
pubkeys = self.keystore.keypairs.keys()
self.receiving_addresses = map(self.pubkeys_to_address, pubkeys)
self.save_addresses()
for addr in self.receiving_addresses:
self.add_address(addr)
@ -1536,35 +1523,22 @@ class Simple_Wallet(Abstract_Wallet):
def load_keystore(self):
self.keystore = load_keystore(self.storage, 'keystore')
self.is_segwit = self.keystore.is_segwit()
self.txin_type = 'p2wpkh-p2sh' if self.is_segwit else 'p2pkh'
def get_pubkey(self, c, i):
pubkey_list = self.change_pubkeys if c else self.receiving_pubkeys
return pubkey_list[i]
return self.derive_pubkeys(c, i)
def get_public_keys(self, address):
return [self.get_public_key(address)]
def add_input_sig_info(self, txin, address):
if not self.keystore.can_import():
txin['derivation'] = derivation = self.get_address_index(address)
derivation = self.get_address_index(address)
x_pubkey = self.keystore.get_xpubkey(*derivation)
pubkey = self.get_pubkey(*derivation)
else:
pubkey = self.get_public_key(address)
assert pubkey is not None
x_pubkey = pubkey
x_pubkey = self.get_public_key(address)
txin['x_pubkeys'] = [x_pubkey]
txin['pubkeys'] = [pubkey]
txin['signatures'] = [None]
addrtype, hash160 = bc_address_to_hash_160(address)
if addrtype == bitcoin.ADDRTYPE_P2SH:
txin['redeemScript'] = self.pubkeys_to_redeem_script(pubkey)
txin['type'] = 'p2wpkh-p2sh'
else:
txin['redeemPubkey'] = pubkey
txin['type'] = 'p2pkh'
txin['num_sig'] = 1
def sign_message(self, address, message, password):
@ -1572,7 +1546,8 @@ class Simple_Wallet(Abstract_Wallet):
return self.keystore.sign_message(index, message, password)
def decrypt_message(self, pubkey, message, password):
index = self.get_pubkey_index(pubkey)
addr = self.pubkeys_to_address(pubkey)
index = self.get_address_index(addr)
return self.keystore.decrypt_message(index, message, password)
@ -1584,7 +1559,7 @@ class Simple_Deterministic_Wallet(Deterministic_Wallet, Simple_Wallet):
def get_master_public_key(self):
return self.keystore.get_master_public_key()
def new_pubkeys(self, c, i):
def derive_pubkeys(self, c, i):
return self.keystore.derive_pubkey(c, i)
def get_keystore(self):
@ -1618,8 +1593,8 @@ class Simple_Deterministic_Wallet(Deterministic_Wallet, Simple_Wallet):
pubkey = self.get_public_key(address)
self.keystore.delete_imported_key(pubkey)
self.save_keystore()
self.receiving_pubkeys.remove(pubkey)
self.receiving_addresses.remove(address)
self.save_addresses()
self.storage.write()
def can_import_privkey(self):
@ -1628,10 +1603,9 @@ class Simple_Deterministic_Wallet(Deterministic_Wallet, Simple_Wallet):
def import_key(self, pk, pw):
pubkey = self.keystore.import_key(pk, pw)
self.save_keystore()
self.receiving_pubkeys.append(pubkey)
self.save_pubkeys()
addr = self.pubkeys_to_address(pubkey)
self.receiving_addresses.append(addr)
self.save_addresses()
self.storage.write()
self.add_address(addr)
return addr
@ -1670,6 +1644,7 @@ class Standard_Wallet(Simple_Deterministic_Wallet):
class Multisig_Wallet(Deterministic_Wallet, P2SH):
# generic m of n
gap_limit = 20
txin_type = 'p2sh'
def __init__(self, storage):
self.wallet_type = storage.get('wallet_type')
@ -1677,8 +1652,7 @@ class Multisig_Wallet(Deterministic_Wallet, P2SH):
Deterministic_Wallet.__init__(self, storage)
def get_pubkeys(self, c, i):
pubkey_list = self.change_pubkeys if c else self.receiving_pubkeys
return pubkey_list[i]
return self.derive_pubkeys(c, i)
def redeem_script(self, c, i):
pubkeys = self.get_pubkeys(c, i)
@ -1687,7 +1661,7 @@ class Multisig_Wallet(Deterministic_Wallet, P2SH):
def pubkeys_to_redeem_script(self, pubkeys):
return transaction.multisig_script(sorted(pubkeys), self.m)
def new_pubkeys(self, c, i):
def derive_pubkeys(self, c, i):
return [k.derive_pubkey(c, i) for k in self.get_keystores()]
def load_keystore(self):
@ -1736,16 +1710,11 @@ class Multisig_Wallet(Deterministic_Wallet, P2SH):
return ''.join(sorted(self.get_master_public_keys()))
def add_input_sig_info(self, txin, address):
txin['derivation'] = derivation = self.get_address_index(address)
pubkeys = self.get_pubkeys(*derivation)
x_pubkeys = [k.get_xpubkey(*derivation) for k in self.get_keystores()]
# sort pubkeys and x_pubkeys, using the order of pubkeys
pubkeys, x_pubkeys = zip(*sorted(zip(pubkeys, x_pubkeys)))
txin['type'] = 'p2sh'
txin['pubkeys'] = list(pubkeys)
txin['x_pubkeys'] = list(x_pubkeys)
txin['signatures'] = [None] * len(pubkeys)
txin['redeemScript'] = self.redeem_script(*derivation)
derivation = self.get_address_index(address)
# extended pubkeys
txin['x_pubkeys'] = [k.get_xpubkey(*derivation) for k in self.get_keystores()]
# we need n place holders
txin['signatures'] = [None] * self.n
txin['num_sig'] = self.m