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

Initial segwit support (testnet only)

This commit is contained in:
ThomasV 2017-01-16 09:48:38 +01:00
parent 11377de398
commit 3a64ec0f2e
11 changed files with 341 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
gui/qt/main_window.py
View File

@ -1343,7 +1343,7 @@ class ElectrumWindow(QMainWindow, MessageBoxMixin, PrintError):
return False, _("Payment request has expired")
status, msg = self.network.broadcast(tx)
if pr and status is True:
pr.set_paid(tx.hash())
pr.set_paid(tx.txid())
self.invoices.save()
self.payment_request = None
refund_address = self.wallet.get_receiving_addresses()[0]
@ -1361,7 +1361,7 @@ class ElectrumWindow(QMainWindow, MessageBoxMixin, PrintError):
status, msg = result
if status:
if tx_desc is not None and tx.is_complete():
self.wallet.set_label(tx.hash(), tx_desc)
self.wallet.set_label(tx.txid(), tx_desc)
parent.show_message(_('Payment sent.') + '\n' + msg)
self.invoice_list.update()
self.do_clear()

45
lib/base_wizard.py
View File

@ -26,7 +26,7 @@
import os
import bitcoin
import keystore
from wallet import Wallet, Imported_Wallet, Standard_Wallet, Multisig_Wallet, WalletStorage, wallet_types
from wallet import Wallet, Imported_Wallet, Standard_Wallet, Segwit_Wallet, Multisig_Wallet, WalletStorage, wallet_types
from i18n import _
from plugins import run_hook
@ -41,6 +41,7 @@ class BaseWizard(object):
self.plugin = None
self.keystores = []
self.is_kivy = config.get('gui') == 'kivy'
self.seed_type = None
def run(self, *args):
action = args[0]
@ -271,25 +272,24 @@ class BaseWizard(object):
self.restore_seed_dialog(run_next=self.on_restore_seed, test=test)
def on_restore_seed(self, seed, is_bip39, is_ext):
if is_bip39:
self.seed_type = 'bip39' if is_bip39 else bitcoin.seed_type(seed)
if self.seed_type == 'bip39':
f = lambda passphrase: self.on_restore_bip39(seed, passphrase)
self.passphrase_dialog(run_next=f) if is_ext else f('')
else:
seed_type = bitcoin.seed_type(seed)
if seed_type == 'standard':
f = lambda passphrase: self.run('create_keystore', seed, passphrase)
self.passphrase_dialog(run_next=f) if is_ext else f('')
elif seed_type == 'old':
self.run('create_keystore', seed, '')
elif seed_type == '2fa':
if self.is_kivy:
self.show_error('2FA seeds are not supported in this version')
self.run('restore_from_seed')
else:
self.load_2fa()
self.run('on_restore_seed', seed, is_ext)
elif self.seed_type in ['standard', 'segwit']:
f = lambda passphrase: self.run('create_keystore', seed, passphrase)
self.passphrase_dialog(run_next=f) if is_ext else f('')
elif self.seed_type == 'old':
self.run('create_keystore', seed, '')
elif self.seed_type == '2fa':
if self.is_kivy:
self.show_error('2FA seeds are not supported in this version')
self.run('restore_from_seed')
else:
raise BaseException('Unknown seed type', seed_type)
self.load_2fa()
self.run('on_restore_seed', seed, is_ext)
else:
raise BaseException('Unknown seed type', seed_type)
def on_restore_bip39(self, seed, passphrase):
f = lambda x: self.run('on_bip44', seed, passphrase, int(x))
@ -337,8 +337,12 @@ class BaseWizard(object):
if k.may_have_password():
k.update_password(None, password)
if self.wallet_type == 'standard':
self.storage.put('seed_type', self.seed_type)
self.storage.put('keystore', k.dump())
self.wallet = Standard_Wallet(self.storage)
if self.seed_type == 'segwit':
self.wallet = Segwit_Wallet(self.storage)
else:
self.wallet = Standard_Wallet(self.storage)
self.run('create_addresses')
elif self.wallet_type == 'multisig':
for i, k in enumerate(self.keystores):
@ -358,8 +362,9 @@ class BaseWizard(object):
self.on_keystore(k)
def create_seed(self):
from electrum.mnemonic import Mnemonic
seed = Mnemonic('en').make_seed()
import mnemonic
self.seed_type = 'segwit' if bitcoin.TESTNET and self.config.get('segwit') else 'standard'
seed = mnemonic.Mnemonic('en').make_seed(self.seed_type)
self.opt_bip39 = False
f = lambda x: self.request_passphrase(seed, x)
self.show_seed_dialog(run_next=f, seed_text=seed)

25
lib/bitcoin.py
View File

@ -40,17 +40,19 @@ import aes
TESTNET = False
ADDRTYPE_P2PKH = 0
ADDRTYPE_P2SH = 5
ADDRTYPE_P2WPKH = 6
XPRV_HEADER = "0488ade4"
XPUB_HEADER = "0488b21e"
HEADERS_URL = "https://headers.electrum.org/blockchain_headers"
def set_testnet():
global ADDRTYPE_P2PKH, ADDRTYPE_P2SH
global ADDRTYPE_P2PKH, ADDRTYPE_P2SH, ADDRTYPE_P2WPKH
global XPRV_HEADER, XPUB_HEADER
global TESTNET, HEADERS_URL
TESTNET = True
ADDRTYPE_P2PKH = 111
ADDRTYPE_P2SH = 196
ADDRTYPE_P2WPKH = 3
XPRV_HEADER = "04358394"
XPUB_HEADER = "043587cf"
HEADERS_URL = "https://headers.electrum.org/testnet_headers"
@ -174,7 +176,6 @@ def Hash(x):
if type(x) is unicode: x=x.encode('utf-8')
return sha256(sha256(x))
hash_encode = lambda x: x[::-1].encode('hex')
hash_decode = lambda x: x.decode('hex')[::-1]
hmac_sha_512 = lambda x,y: hmac.new(x, y, hashlib.sha512).digest()
@ -207,6 +208,8 @@ def seed_type(x):
return 'old'
elif is_new_seed(x):
return 'standard'
elif TESTNET and is_new_seed(x, version.SEED_PREFIX_SW):
return 'segwit'
elif is_new_seed(x, version.SEED_PREFIX_2FA):
return '2fa'
return ''
@ -247,11 +250,12 @@ def hash_160(public_key):
md.update(sha256(public_key))
return md.digest()
def hash_160_to_bc_address(h160, addrtype):
vh160 = chr(addrtype) + h160
h = Hash(vh160)
addr = vh160 + h[0:4]
return base_encode(addr, base=58)
def hash_160_to_bc_address(h160, addrtype, witness_program_version=1):
s = chr(addrtype)
if addrtype == ADDRTYPE_P2WPKH:
s += chr(witness_program_version) + chr(0)
s += h160
return base_encode(s+Hash(s)[0:4], base=58)
def bc_address_to_hash_160(addr):
bytes = base_decode(addr, 25, base=58)
@ -263,9 +267,14 @@ def hash160_to_p2pkh(h160):
def hash160_to_p2sh(h160):
return hash_160_to_bc_address(h160, ADDRTYPE_P2SH)
def public_key_to_bc_address(public_key):
def public_key_to_p2pkh(public_key):
return hash160_to_p2pkh(hash_160(public_key))
def public_key_to_p2wpkh(public_key):
return hash160_to_bc_address(hash_160(public_key), ADDRTYPE_P2WPKH)
__b58chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
assert len(__b58chars) == 58

1
lib/commands.py
View File

@ -747,6 +747,7 @@ def get_parser():
group.add_argument("-P", "--portable", action="store_true", dest="portable", default=False, help="Use local 'electrum_data' directory")
group.add_argument("-w", "--wallet", dest="wallet_path", help="wallet path")
group.add_argument("--testnet", action="store_true", dest="testnet", default=False, help="Use Testnet")
group.add_argument("--segwit", action="store_true", dest="segwit", default=False, help="The Wizard will create Segwit seed phrases (Testnet only).")
# create main parser
parser = argparse.ArgumentParser(
parents=[parent_parser],

25
lib/keystore.py
View File

@ -30,7 +30,7 @@ from unicodedata import normalize
from version import *
import bitcoin
from bitcoin import pw_encode, pw_decode, bip32_root, bip32_private_derivation, bip32_public_derivation, bip32_private_key, deserialize_xprv, deserialize_xpub
from bitcoin import public_key_from_private_key, public_key_to_bc_address
from bitcoin import public_key_from_private_key, public_key_to_p2pkh
from bitcoin import *
from bitcoin import is_old_seed, is_new_seed, is_seed
@ -166,7 +166,7 @@ class Imported_KeyStore(Software_KeyStore):
# fixme: this assumes p2pkh
_, addr = xpubkey_to_address(x_pubkey)
for pubkey in self.keypairs.keys():
if public_key_to_bc_address(pubkey.decode('hex')) == addr:
if public_key_to_p2pkh(pubkey.decode('hex')) == addr:
return pubkey
def update_password(self, old_password, new_password):
@ -398,7 +398,7 @@ class Old_KeyStore(Deterministic_KeyStore):
def get_address(self, for_change, n):
pubkey = self.get_pubkey(for_change, n)
address = public_key_to_bc_address(pubkey.decode('hex'))
address = public_key_to_p2pkh(pubkey.decode('hex'))
return address
@classmethod
@ -563,6 +563,11 @@ def parse_xpubkey(x_pubkey):
return BIP32_KeyStore.parse_xpubkey(x_pubkey)
def xpubkey_to_address(x_pubkey):
if x_pubkey[0:2] == 'fd':
addrtype = ord(x_pubkey[2:4].decode('hex'))
hash160 = x_pubkey[4:].decode('hex')
address = bitcoin.hash_160_to_bc_address(hash160, addrtype)
return x_pubkey, address
if x_pubkey[0:2] in ['02','03','04']:
pubkey = x_pubkey
elif x_pubkey[0:2] == 'ff':
@ -571,15 +576,10 @@ def xpubkey_to_address(x_pubkey):
elif x_pubkey[0:2] == 'fe':
mpk, s = Old_KeyStore.parse_xpubkey(x_pubkey)
pubkey = Old_KeyStore.get_pubkey_from_mpk(mpk, s[0], s[1])
elif x_pubkey[0:2] == 'fd':
addrtype = ord(x_pubkey[2:4].decode('hex'))
hash160 = x_pubkey[4:].decode('hex')
pubkey = None
address = hash_160_to_bc_address(hash160, addrtype)
else:
raise BaseException("Cannnot parse pubkey")
raise BaseException("Cannot parse pubkey")
if pubkey:
address = public_key_to_bc_address(pubkey.decode('hex'))
address = public_key_to_p2pkh(pubkey.decode('hex'))
return pubkey, address
@ -660,10 +660,11 @@ def bip44_derivation(account_id):
return "m/44'/0'/%d'"% int(account_id)
def from_seed(seed, passphrase):
if is_old_seed(seed):
t = seed_type(seed)
if t == 'old':
keystore = Old_KeyStore({})
keystore.add_seed(seed)
elif is_new_seed(seed):
elif t in ['standard', 'segwit']:
keystore = BIP32_KeyStore({})
keystore.add_seed(seed)
keystore.passphrase = passphrase

4
lib/mnemonic.py
View File

@ -159,7 +159,9 @@ class Mnemonic(object):
i = self.mnemonic_decode(seed)
return i % custom_entropy == 0
def make_seed(self, num_bits=128, prefix=version.SEED_PREFIX, custom_entropy=1):
def make_seed(self, seed_type='standard', num_bits=128, custom_entropy=1):
import version
prefix = version.seed_prefix(seed_type)
# increase num_bits in order to obtain a uniform distibution for the last word
bpw = math.log(len(self.wordlist), 2)
num_bits = int(math.ceil(num_bits/bpw)) * bpw

2
lib/network.py
View File

@ -847,7 +847,7 @@ class Network(util.DaemonThread):
return r.get('result')
def broadcast(self, tx, timeout=30):
tx_hash = tx.hash()
tx_hash = tx.txid()
try:
out = self.synchronous_get(('blockchain.transaction.broadcast', [str(tx)]), timeout)
except BaseException as e:

2
lib/synchronizer.py
View File

@ -136,7 +136,7 @@ class Synchronizer(ThreadJob):
if not params:
return
tx_hash, tx_height = params
assert tx_hash == hash_encode(Hash(result.decode('hex')))
#assert tx_hash == hash_encode(Hash(result.decode('hex')))
tx = Transaction(result)
try:
tx.deserialize()

287
lib/transaction.py
View File

@ -303,15 +303,26 @@ def parse_scriptSig(d, bytes):
print_error("cannot find address in input script", bytes.encode('hex'))
return
# payto_pubkey
match = [ opcodes.OP_PUSHDATA4 ]
if match_decoded(decoded, match):
sig = decoded[0][1].encode('hex')
d['address'] = "(pubkey)"
d['signatures'] = [sig]
d['num_sig'] = 1
d['x_pubkeys'] = ["(pubkey)"]
d['pubkeys'] = ["(pubkey)"]
item = decoded[0][1]
if item[0] == chr(0):
redeemScript = item.encode('hex')
d['address'] = bitcoin.hash160_to_p2sh(bitcoin.hash_160(redeemScript.decode('hex')))
d['type'] = 'p2wpkh-p2sh'
d['redeemScript'] = redeemScript
d['x_pubkeys'] = ["(witness)"]
d['pubkeys'] = ["(witness)"]
d['signatures'] = ['(witness)']
d['num_sig'] = 1
else:
# payto_pubkey
d['type'] = 'p2pk'
d['address'] = "(pubkey)"
d['signatures'] = [item.encode('hex')]
d['num_sig'] = 1
d['x_pubkeys'] = ["(pubkey)"]
d['pubkeys'] = ["(pubkey)"]
return
# non-generated TxIn transactions push a signature
@ -329,6 +340,7 @@ def parse_scriptSig(d, bytes):
traceback.print_exc(file=sys.stdout)
print_error("cannot find address in input script", bytes.encode('hex'))
return
d['type'] = 'p2pkh'
d['signatures'] = signatures
d['x_pubkeys'] = [x_pubkey]
d['num_sig'] = 1
@ -353,8 +365,9 @@ def parse_scriptSig(d, bytes):
return
x_pubkeys = map(lambda x: x[1].encode('hex'), dec2[1:-2])
pubkeys = [xpubkey_to_address(x)[0] for x in x_pubkeys]
redeemScript = Transaction.multisig_script(pubkeys, m)
redeemScript = multisig_script(pubkeys, m)
# write result in d
d['type'] = 'p2sh'
d['num_sig'] = m
d['signatures'] = parse_sig(x_sig)
d['x_pubkeys'] = x_pubkeys
@ -412,6 +425,10 @@ def parse_input(vds):
parse_scriptSig(d, scriptSig)
return d
def parse_witness(vds):
n = vds.read_compact_size()
for i in range(n):
x = vds.read_bytes(vds.read_compact_size())
def parse_output(vds, i):
d = {}
@ -430,16 +447,54 @@ def deserialize(raw):
start = vds.read_cursor
d['version'] = vds.read_int32()
n_vin = vds.read_compact_size()
is_segwit = (n_vin == 0)
if is_segwit:
marker = vds.read_bytes(1)
assert marker == chr(1)
n_vin = vds.read_compact_size()
d['inputs'] = list(parse_input(vds) for i in xrange(n_vin))
n_vout = vds.read_compact_size()
d['outputs'] = list(parse_output(vds,i) for i in xrange(n_vout))
if is_segwit:
d['witness'] = list(parse_witness(vds) for i in xrange(n_vin))
d['lockTime'] = vds.read_uint32()
return d
# pay & redeem scripts
def push_script(x):
return op_push(len(x)/2) + x
def get_scriptPubKey(addr):
addrtype, hash_160 = bc_address_to_hash_160(addr)
if addrtype == bitcoin.ADDRTYPE_P2PKH:
script = '76a9' # op_dup, op_hash_160
script += push_script(hash_160.encode('hex'))
script += '88ac' # op_equalverify, op_checksig
elif addrtype == bitcoin.ADDRTYPE_P2SH:
script = 'a9' # op_hash_160
script += push_script(hash_160.encode('hex'))
script += '87' # op_equal
else:
raise BaseException('unknown address type')
return script
def segwit_script(pubkey):
pkh = hash_160(pubkey.decode('hex')).encode('hex')
return '00' + push_script(pkh)
def multisig_script(public_keys, m):
n = len(public_keys)
assert n <= 15
assert m <= n
op_m = format(opcodes.OP_1 + m - 1, 'x')
op_n = format(opcodes.OP_1 + n - 1, 'x')
keylist = [op_push(len(k)/2) + k for k in public_keys]
return op_m + ''.join(keylist) + op_n + 'ae'
class Transaction:
@ -485,7 +540,7 @@ class Transaction:
for sig in sigs2:
if sig in sigs1:
continue
for_sig = Hash(self.tx_for_sig(i).decode('hex'))
pre_hash = Hash(self.serialize_preimage(i).decode('hex'))
# der to string
order = ecdsa.ecdsa.generator_secp256k1.order()
r, s = ecdsa.util.sigdecode_der(sig.decode('hex'), order)
@ -493,10 +548,10 @@ class Transaction:
pubkeys = txin.get('pubkeys')
compressed = True
for recid in range(4):
public_key = MyVerifyingKey.from_signature(sig_string, recid, for_sig, curve = SECP256k1)
public_key = MyVerifyingKey.from_signature(sig_string, recid, pre_hash, curve = SECP256k1)
pubkey = point_to_ser(public_key.pubkey.point, compressed).encode('hex')
if pubkey in pubkeys:
public_key.verify_digest(sig_string, for_sig, sigdecode = ecdsa.util.sigdecode_string)
public_key.verify_digest(sig_string, pre_hash, sigdecode = ecdsa.util.sigdecode_string)
j = pubkeys.index(pubkey)
print_error("adding sig", i, j, pubkey, sig)
self._inputs[i]['signatures'][j] = sig
@ -525,92 +580,72 @@ class Transaction:
self.locktime = locktime
return self
@classmethod
def multisig_script(klass, public_keys, m):
n = len(public_keys)
assert n <= 15
assert m <= n
op_m = format(opcodes.OP_1 + m - 1, 'x')
op_n = format(opcodes.OP_1 + n - 1, 'x')
keylist = [op_push(len(k)/2) + k for k in public_keys]
return op_m + ''.join(keylist) + op_n + 'ae'
@classmethod
def pay_script(self, output_type, addr):
if output_type == TYPE_SCRIPT:
return addr.encode('hex')
elif output_type == TYPE_ADDRESS:
addrtype, hash_160 = bc_address_to_hash_160(addr)
if addrtype == bitcoin.ADDRTYPE_P2PKH:
script = '76a9' # op_dup, op_hash_160
script += push_script(hash_160.encode('hex'))
script += '88ac' # op_equalverify, op_checksig
elif addrtype == bitcoin.ADDRTYPE_P2SH:
script = 'a9' # op_hash_160
script += push_script(hash_160.encode('hex'))
script += '87' # op_equal
else:
raise
return get_scriptPubKey(addr)
else:
raise
raise BaseException('Unknown output type')
return script
@classmethod
def input_script(self, txin, i, for_sig):
# for_sig:
# -1 : do not sign, estimate length
# i>=0 : serialized tx for signing input i
# None : add all known signatures
p2sh = txin.get('redeemScript') is not None
num_sig = txin['num_sig'] if p2sh else 1
address = txin['address']
def get_siglist(self, txin, estimate_size=False):
# 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 for_sig in [-1, None]:
# if we have enough signatures, we use the actual pubkeys
# use extended pubkeys (with bip32 derivation)
if for_sig == -1:
# we assume that signature will be 0x48 bytes long
pubkeys = txin['pubkeys']
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)
script = ''.join(push_script(x) for x in sig_list)
if not pubkeys:
pass
elif not p2sh:
x_pubkey = pubkeys[0]
if x_pubkey is None:
addrtype, h160 = bc_address_to_hash_160(txin['address'])
x_pubkey = 'fd' + (chr(addrtype) + h160).encode('hex')
script += push_script(x_pubkey)
else:
script = '00' + script # put op_0 in front of script
redeem_script = self.multisig_script(pubkeys, num_sig)
script += push_script(redeem_script)
elif for_sig==i:
script = txin['redeemScript'] if p2sh else self.pay_script(TYPE_ADDRESS, address)
if estimate_size:
# we assume that signature will be 0x48 bytes long
pubkeys = txin['pubkeys']
sig_list = [ "00" * 0x48 ] * num_sig
elif is_complete:
pubkeys = txin['pubkeys']
sig_list = [(sig + '01') for sig in signatures]
else:
script = ''
pubkeys = txin['x_pubkeys']
sig_list = [(sig + '01') if sig else NO_SIGNATURE for sig in x_signatures]
return pubkeys, sig_list
@classmethod
def serialize_witness(self, txin):
pubkeys, sig_list = self.get_siglist(txin)
n = len(pubkeys) + len(sig_list)
return var_int(n) + ''.join(push_script(x) for x in sig_list) + ''.join(push_script(x) for x in pubkeys)
@classmethod
def is_segwit_input(self, txin):
return txin['type'] in ['p2wpkh-p2sh']
@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)
pubkeys, sig_list = self.get_siglist(txin, estimate_size)
script = ''.join(push_script(x) for x in sig_list)
if not pubkeys:
pass
elif redeem_script:
# put op_0 before script
script = '00' + script
script += push_script(redeem_script)
else:
script += push_script(pubkeys[0])
return script
@classmethod
def serialize_input(self, txin, i, for_sig):
def serialize_outpoint(self, txin):
return txin['prevout_hash'].decode('hex')[::-1].encode('hex') + int_to_hex(txin['prevout_n'], 4)
@classmethod
def serialize_input(self, txin, script):
# Prev hash and index
s = txin['prevout_hash'].decode('hex')[::-1].encode('hex')
s += int_to_hex(txin['prevout_n'], 4)
s = self.serialize_outpoint(txin)
# Script length, script, sequence
script = self.input_script(txin, i, for_sig)
s += var_int(len(script)/2)
s += script
s += int_to_hex(txin.get('sequence', 0xffffffff), 4)
@ -625,30 +660,71 @@ class Transaction:
self._inputs.sort(key = lambda i: (i['prevout_hash'], i['prevout_n']))
self._outputs.sort(key = lambda o: (o[2], self.pay_script(o[0], o[1])))
def serialize(self, for_sig=None):
inputs = self.inputs()
outputs = self.outputs()
s = int_to_hex(1, 4) # version
s += var_int(len(inputs)) # number of inputs
for i, txin in enumerate(inputs):
s += self.serialize_input(txin, i, for_sig)
s += var_int(len(outputs)) # number of outputs
for output in outputs:
output_type, addr, amount = output
s += int_to_hex(amount, 8) # amount
script = self.pay_script(output_type, addr)
s += var_int(len(script)/2) # script length
s += script # script
s += int_to_hex(self.locktime, 4) # locktime
if for_sig is not None and for_sig != -1:
s += int_to_hex(1, 4) # hash type
def serialize_output(self, output):
output_type, addr, amount = output
s = int_to_hex(amount, 8)
script = self.pay_script(output_type, addr)
s += var_int(len(script)/2)
s += script
return s
def tx_for_sig(self,i):
return self.serialize(for_sig = i)
def serialize_preimage(self, i):
nVersion = int_to_hex(1, 4)
nHashType = int_to_hex(1, 4)
nLocktime = int_to_hex(self.locktime, 4)
inputs = self.inputs()
outputs = self.outputs()
txin = inputs[i]
if self.is_segwit_input(txin):
hashPrevouts = Hash(''.join(self.serialize_outpoint(txin) for txin in inputs).decode('hex')).encode('hex')
hashSequence = Hash(''.join(int_to_hex(txin.get('sequence', 0xffffffff), 4) for txin in inputs).decode('hex')).encode('hex')
hashOutputs = Hash(''.join(self.serialize_output(o) for o in outputs).decode('hex')).encode('hex')
outpoint = self.serialize_outpoint(txin)
pubkey = txin['pubkeys'][0]
pkh = bitcoin.hash_160(pubkey.decode('hex')).encode('hex')
redeemScript = '00' + push_script(pkh)
scriptCode = push_script('76a9' + push_script(pkh) + '88ac')
script_hash = bitcoin.hash_160(redeemScript.decode('hex')).encode('hex')
scriptPubKey = 'a9' + push_script(script_hash) + '87'
amount = int_to_hex(txin['value'], 8)
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))
txouts = var_int(len(outputs)) + ''.join(self.serialize_output(o) for o in outputs)
preimage = nVersion + txins + txouts + nLocktime + nHashType
return preimage
def is_segwit(self):
return any(self.is_segwit_input(x) for x in self.inputs())
def serialize(self, estimate_size=False, witness=True):
nVersion = int_to_hex(1, 4)
nLocktime = int_to_hex(self.locktime, 4)
inputs = self.inputs()
outputs = self.outputs()
txins = var_int(len(inputs)) + ''.join(self.serialize_input(txin, self.input_script(txin, estimate_size)) for txin in inputs)
txouts = var_int(len(outputs)) + ''.join(self.serialize_output(o) for o in outputs)
if witness and self.is_segwit():
marker = '00'
flag = '01'
witness = ''.join(self.serialize_witness(x) for x in inputs)
return nVersion + marker + flag + txins + txouts + witness + nLocktime
else:
return nVersion + txins + txouts + nLocktime
def hash(self):
return Hash(self.raw.decode('hex'))[::-1].encode('hex')
print "warning: deprecated tx.hash()"
return self.txid()
def txid(self):
ser = self.serialize(witness=False)
return Hash(ser.decode('hex'))[::-1].encode('hex')
def wtxid(self):
ser = self.serialize(witness=True)
return Hash(ser.decode('hex'))[::-1].encode('hex')
def add_inputs(self, inputs):
self._inputs.extend(inputs)
@ -662,7 +738,7 @@ class Transaction:
return sum(x['value'] for x in self.inputs())
def output_value(self):
return sum( val for tp,addr,val in self.outputs())
return sum(val for tp, addr, val in self.outputs())
def get_fee(self):
return self.input_value() - self.output_value()
@ -673,12 +749,13 @@ class Transaction:
@profiler
def estimated_size(self):
'''Return an estimated tx size in bytes.'''
return len(self.serialize(-1)) / 2 if not self.is_complete() or self.raw is None else len(self.raw) / 2 # ASCII hex string
return len(self.serialize(True)) / 2 if not self.is_complete() or self.raw is None else len(self.raw) / 2 # ASCII hex string
@classmethod
def estimated_input_size(self, txin):
'''Return an estimated of serialized input size in bytes.'''
return len(self.serialize_input(txin, -1, -1)) / 2
script = self.input_script(txin, True)
return len(self.serialize_input(txin, script)) / 2
def signature_count(self):
r = 0
@ -723,13 +800,13 @@ class Transaction:
txin['pubkeys'][ii] = pubkey
self._inputs[i] = txin
# add signature
for_sig = Hash(self.tx_for_sig(i).decode('hex'))
pre_hash = Hash(self.serialize_preimage(i).decode('hex'))
pkey = regenerate_key(sec)
secexp = pkey.secret
private_key = bitcoin.MySigningKey.from_secret_exponent( secexp, curve = SECP256k1 )
private_key = bitcoin.MySigningKey.from_secret_exponent(secexp, curve = SECP256k1)
public_key = private_key.get_verifying_key()
sig = private_key.sign_digest_deterministic( for_sig, hashfunc=hashlib.sha256, sigencode = ecdsa.util.sigencode_der )
assert public_key.verify_digest( sig, for_sig, sigdecode = ecdsa.util.sigdecode_der)
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')
self._inputs[i] = txin
print_error("is_complete", self.is_complete())

10
lib/version.py
View File

@ -3,4 +3,14 @@ PROTOCOL_VERSION = '0.10' # protocol version requested
# The hash of the mnemonic seed must begin with this
SEED_PREFIX = '01' # Electrum standard wallet
SEED_PREFIX_SW = '02' # Electrum segwit wallet
SEED_PREFIX_2FA = '101' # extended seed for two-factor authentication
def seed_prefix(seed_type):
if seed_type == 'standard':
return SEED_PREFIX
elif seed_type == 'segwit':
return SEED_PREFIX_SW
elif seed_type == '2Fa':
return SEED_PREFIX_2FA

134
lib/wallet.py
View File

@ -52,6 +52,7 @@ from version import *
from keystore import load_keystore, Hardware_KeyStore
from storage import multisig_type
import transaction
from transaction import Transaction
from plugins import run_hook
import bitcoin
@ -436,7 +437,7 @@ class Abstract_Wallet(PrintError):
label = ''
height = conf = timestamp = None
if tx.is_complete():
tx_hash = tx.hash()
tx_hash = tx.txid()
if tx_hash in self.transactions.keys():
label = self.get_label(tx_hash)
height, conf, timestamp = self.get_tx_height(tx_hash)
@ -879,7 +880,7 @@ class Abstract_Wallet(PrintError):
pubkey = public_key_from_private_key(privkey)
address = address_from_private_key(privkey)
u = network.synchronous_get(('blockchain.address.listunspent', [address]))
pay_script = Transaction.pay_script(TYPE_ADDRESS, address)
pay_script = transaction.get_scriptPubKey(address)
for item in u:
if len(inputs) >= imax:
break
@ -1381,45 +1382,9 @@ class Imported_Wallet(Abstract_Wallet):
txin['x_pubkeys'] = [ xpubkey ]
txin['pubkeys'] = [ xpubkey ]
txin['signatures'] = [None]
txin['type'] = 'unknown'
class P2PKH_Wallet(Abstract_Wallet):
def pubkeys_to_address(self, pubkey):
return public_key_to_bc_address(pubkey.decode('hex'))
def load_keystore(self):
self.keystore = load_keystore(self.storage, 'keystore')
def get_pubkey(self, c, i):
pubkey_list = self.change_pubkeys if c else self.receiving_pubkeys
return pubkey_list[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)
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
txin['x_pubkeys'] = [x_pubkey]
txin['pubkeys'] = [pubkey]
txin['signatures'] = [None]
txin['redeemPubkey'] = pubkey
txin['num_sig'] = 1
def sign_message(self, address, message, password):
index = self.get_address_index(address)
return self.keystore.sign_message(index, message, password)
def decrypt_message(self, pubkey, message, password):
index = self.get_pubkey_index(pubkey)
return self.keystore.decrypt_message(index, message, password)
class Deterministic_Wallet(Abstract_Wallet):
@ -1545,8 +1510,53 @@ class Deterministic_Wallet(Abstract_Wallet):
class Standard_Wallet(Deterministic_Wallet, P2PKH_Wallet):
wallet_type = 'standard'
class Simple_Wallet(Abstract_Wallet):
""" Wallet with a single pubkey per address """
def load_keystore(self):
self.keystore = load_keystore(self.storage, 'keystore')
def get_pubkey(self, c, i):
pubkey_list = self.change_pubkeys if c else self.receiving_pubkeys
return pubkey_list[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)
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
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):
index = self.get_address_index(address)
return self.keystore.sign_message(index, message, password)
def decrypt_message(self, pubkey, message, password):
index = self.get_pubkey_index(pubkey)
return self.keystore.decrypt_message(index, message, password)
class Simple_Deterministic_Wallet(Deterministic_Wallet, Simple_Wallet):
def __init__(self, storage):
Deterministic_Wallet.__init__(self, storage)
@ -1607,7 +1617,35 @@ class Standard_Wallet(Deterministic_Wallet, P2PKH_Wallet):
return addr
class Multisig_Wallet(Deterministic_Wallet):
class P2SH:
def pubkeys_to_redeem_script(self, pubkeys):
raise NotImplementedError()
def pubkeys_to_address(self, pubkeys):
redeem_script = self.pubkeys_to_redeem_script(pubkeys)
return bitcoin.hash160_to_p2sh(hash_160(redeem_script.decode('hex')))
class P2PKH:
def pubkeys_to_address(self, pubkey):
return bitcoin.public_key_to_p2pkh(pubkey.decode('hex'))
class Standard_Wallet(Simple_Deterministic_Wallet, P2PKH):
wallet_type = 'standard'
class Segwit_Wallet(Simple_Deterministic_Wallet, P2SH):
wallet_type = 'segwit'
def pubkeys_to_redeem_script(self, pubkey):
return transaction.segwit_script(pubkey)
class Multisig_Wallet(Deterministic_Wallet, P2SH):
# generic m of n
gap_limit = 20
@ -1622,12 +1660,10 @@ class Multisig_Wallet(Deterministic_Wallet):
def redeem_script(self, c, i):
pubkeys = self.get_pubkeys(c, i)
return Transaction.multisig_script(sorted(pubkeys), self.m)
return transaction.multisig_script(sorted(pubkeys), self.m)
def pubkeys_to_address(self, pubkeys):
redeem_script = Transaction.multisig_script(sorted(pubkeys), self.m)
address = hash_160_to_bc_address(hash_160(redeem_script.decode('hex')), bitcoin.ADDRTYPE_P2SH)
return address
def pubkeys_to_redeem_script(self, pubkeys):
return transaction.multisig_script(sorted(pubkeys), self.m)
def new_pubkeys(self, c, i):
return [k.derive_pubkey(c, i) for k in self.get_keystores()]
@ -1683,6 +1719,7 @@ class Multisig_Wallet(Deterministic_Wallet):
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)
@ -1699,7 +1736,8 @@ wallet_constructors = {
'standard': Standard_Wallet,
'old': Standard_Wallet,
'xpub': Standard_Wallet,
'imported': Imported_Wallet
'imported': Imported_Wallet,
'segwit': Segwit_Wallet
}
def register_constructor(wallet_type, constructor):