new wallet structure:
- store addresses instead of pubkeys - derive pubkeys only for serialization - fix #2024
This commit is contained in:
parent
b1f27d7e84
commit
ff39068867
|
@ -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()
|
||||
|
|
|
@ -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 = {}
|
||||
|
||||
|
|
|
@ -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
113
lib/wallet.py
|
@ -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
|
||||
|
||||
|
||||
|
|
Loading…
Reference in New Issue