replace segwit wallet class with custom xpub type
This commit is contained in:
ThomasV
parent
3a64ec0f2e
commit
ce11a2fac5
|
|
@ -26,7 +26,7 @@
|
|||
import os
|
||||
import bitcoin
|
||||
import keystore
|
||||
from wallet import Wallet, Imported_Wallet, Standard_Wallet, Segwit_Wallet, Multisig_Wallet, WalletStorage, wallet_types
|
||||
from wallet import Wallet, Imported_Wallet, Standard_Wallet, Multisig_Wallet, WalletStorage, wallet_types
|
||||
from i18n import _
|
||||
from plugins import run_hook
|
||||
|
||||
|
|
@ -339,10 +339,7 @@ class BaseWizard(object):
|
|||
if self.wallet_type == 'standard':
|
||||
self.storage.put('seed_type', self.seed_type)
|
||||
self.storage.put('keystore', k.dump())
|
||||
if self.seed_type == 'segwit':
|
||||
self.wallet = Segwit_Wallet(self.storage)
|
||||
else:
|
||||
self.wallet = Standard_Wallet(self.storage)
|
||||
self.wallet = Standard_Wallet(self.storage)
|
||||
self.run('create_addresses')
|
||||
elif self.wallet_type == 'multisig':
|
||||
for i, k in enumerate(self.keystores):
|
||||
|
|
|
|||
|
|
@ -41,8 +41,8 @@ TESTNET = False
|
|||
ADDRTYPE_P2PKH = 0
|
||||
ADDRTYPE_P2SH = 5
|
||||
ADDRTYPE_P2WPKH = 6
|
||||
XPRV_HEADER = "0488ade4"
|
||||
XPUB_HEADER = "0488b21e"
|
||||
XPRV_HEADER = 0x0488ade4
|
||||
XPUB_HEADER = 0x0488b21e
|
||||
HEADERS_URL = "https://headers.electrum.org/blockchain_headers"
|
||||
|
||||
def set_testnet():
|
||||
|
|
@ -53,10 +53,13 @@ def set_testnet():
|
|||
ADDRTYPE_P2PKH = 111
|
||||
ADDRTYPE_P2SH = 196
|
||||
ADDRTYPE_P2WPKH = 3
|
||||
XPRV_HEADER = "04358394"
|
||||
XPUB_HEADER = "043587cf"
|
||||
XPRV_HEADER = 0x04358394
|
||||
XPUB_HEADER = 0x043587cf
|
||||
HEADERS_URL = "https://headers.electrum.org/testnet_headers"
|
||||
|
||||
|
||||
|
||||
|
||||
################################## transactions
|
||||
|
||||
FEE_STEP = 10000
|
||||
|
|
@ -736,20 +739,35 @@ def _CKD_pub(cK, c, s):
|
|||
return cK_n, c_n
|
||||
|
||||
|
||||
def xprv_header(xtype):
|
||||
return ("%08x"%(XPRV_HEADER + xtype)).decode('hex')
|
||||
|
||||
def xpub_header(xtype):
|
||||
return ("%08x"%(XPUB_HEADER + xtype)).decode('hex')
|
||||
|
||||
def serialize_xpub(xtype, c, k):
|
||||
xprv = xprv_header(xtype) + chr(0)*9 + c + chr(0) + k
|
||||
return EncodeBase58Check(xprv)
|
||||
|
||||
def serialize_xpub(xtype, c, cK, depth=0, fingerprint=chr(0)*4, child_number=chr(0)*4):
|
||||
xpub = xpub_header(xtype) + chr(depth) + fingerprint + child_number + c + cK
|
||||
return EncodeBase58Check(xpub)
|
||||
|
||||
def deserialize_xkey(xkey, prv):
|
||||
header = XPRV_HEADER if prv else XPUB_HEADER
|
||||
xkey = DecodeBase58Check(xkey)
|
||||
assert len(xkey) == 78
|
||||
if len(xkey) != 78:
|
||||
raise BaseException('Invalid length')
|
||||
depth = ord(xkey[4])
|
||||
fingerprint = xkey[5:9]
|
||||
child_number = xkey[9:13]
|
||||
c = xkey[13:13+32]
|
||||
if xkey[0:4].encode('hex') == header:
|
||||
n = 33 if prv else 32
|
||||
K_or_k = xkey[13+n:]
|
||||
else:
|
||||
raise BaseException('wrong key')
|
||||
return depth, fingerprint, child_number, c, K_or_k
|
||||
header = XPRV_HEADER if prv else XPUB_HEADER
|
||||
xtype = int('0x' + xkey[0:4].encode('hex'), 16) - header
|
||||
if xtype not in ([0, 1] if TESTNET else [0]):
|
||||
raise BaseException('Invalid header')
|
||||
n = 33 if prv else 32
|
||||
K_or_k = xkey[13+n:]
|
||||
return xtype, depth, fingerprint, child_number, c, K_or_k
|
||||
|
||||
def deserialize_xpub(xkey):
|
||||
return deserialize_xkey(xkey, False)
|
||||
|
|
@ -757,36 +775,46 @@ def deserialize_xpub(xkey):
|
|||
def deserialize_xprv(xkey):
|
||||
return deserialize_xkey(xkey, True)
|
||||
|
||||
def is_xpub(text):
|
||||
try:
|
||||
deserialize_xpub(text)
|
||||
return True
|
||||
except:
|
||||
return False
|
||||
|
||||
def is_xprv(text):
|
||||
try:
|
||||
deserialize_xprv(text)
|
||||
return True
|
||||
except:
|
||||
return False
|
||||
|
||||
|
||||
def xpub_from_xprv(xprv):
|
||||
depth, fingerprint, child_number, c, k = deserialize_xprv(xprv)
|
||||
xtype, depth, fingerprint, child_number, c, k = deserialize_xprv(xprv)
|
||||
K, cK = get_pubkeys_from_secret(k)
|
||||
xpub = XPUB_HEADER.decode('hex') + chr(depth) + fingerprint + child_number + c + cK
|
||||
return EncodeBase58Check(xpub)
|
||||
return serialize_xpub(xtype, c, cK, depth, fingerprint, child_number)
|
||||
|
||||
|
||||
def bip32_root(seed):
|
||||
def bip32_root(seed, xtype):
|
||||
I = hmac.new("Bitcoin seed", seed, hashlib.sha512).digest()
|
||||
master_k = I[0:32]
|
||||
master_c = I[32:]
|
||||
K, cK = get_pubkeys_from_secret(master_k)
|
||||
xprv = (XPRV_HEADER + "00" + "00000000" + "00000000").decode("hex") + master_c + chr(0) + master_k
|
||||
xpub = (XPUB_HEADER + "00" + "00000000" + "00000000").decode("hex") + master_c + cK
|
||||
return EncodeBase58Check(xprv), EncodeBase58Check(xpub)
|
||||
xprv = serialize_xprv(xtype, master_c, master_k)
|
||||
xpub = serialize_xpub(xtype, master_c + cK)
|
||||
return xprv, xpub
|
||||
|
||||
|
||||
def xpub_from_pubkey(cK):
|
||||
def xpub_from_pubkey(xtype, cK):
|
||||
assert cK[0] in ['\x02','\x03']
|
||||
master_c = chr(0)*32
|
||||
xpub = (XPUB_HEADER + "00" + "00000000" + "00000000").decode("hex") + master_c + cK
|
||||
return EncodeBase58Check(xpub)
|
||||
return serialize_xpub(xtype, chr(0)*32, cK)
|
||||
|
||||
|
||||
def bip32_private_derivation(xprv, branch, sequence):
|
||||
assert sequence.startswith(branch)
|
||||
if branch == sequence:
|
||||
return xprv, xpub_from_xprv(xprv)
|
||||
depth, fingerprint, child_number, c, k = deserialize_xprv(xprv)
|
||||
xtype, depth, fingerprint, child_number, c, k = deserialize_xprv(xprv)
|
||||
sequence = sequence[len(branch):]
|
||||
for n in sequence.split('/'):
|
||||
if n == '': continue
|
||||
|
|
@ -799,13 +827,13 @@ def bip32_private_derivation(xprv, branch, sequence):
|
|||
fingerprint = hash_160(parent_cK)[0:4]
|
||||
child_number = ("%08X"%i).decode('hex')
|
||||
K, cK = get_pubkeys_from_secret(k)
|
||||
xprv = XPRV_HEADER.decode('hex') + chr(depth) + fingerprint + child_number + c + chr(0) + k
|
||||
xpub = XPUB_HEADER.decode('hex') + chr(depth) + fingerprint + child_number + c + cK
|
||||
xprv = xprv_header(xtype) + chr(depth) + fingerprint + child_number + c + chr(0) + k
|
||||
xpub = xpub_header(xtype) + chr(depth) + fingerprint + child_number + c + cK
|
||||
return EncodeBase58Check(xprv), EncodeBase58Check(xpub)
|
||||
|
||||
|
||||
def bip32_public_derivation(xpub, branch, sequence):
|
||||
depth, fingerprint, child_number, c, cK = deserialize_xpub(xpub)
|
||||
xtype, depth, fingerprint, child_number, c, cK = deserialize_xpub(xpub)
|
||||
assert sequence.startswith(branch)
|
||||
sequence = sequence[len(branch):]
|
||||
for n in sequence.split('/'):
|
||||
|
|
@ -816,7 +844,7 @@ def bip32_public_derivation(xpub, branch, sequence):
|
|||
depth += 1
|
||||
fingerprint = hash_160(parent_cK)[0:4]
|
||||
child_number = ("%08X"%i).decode('hex')
|
||||
xpub = XPUB_HEADER.decode('hex') + chr(depth) + fingerprint + child_number + c + cK
|
||||
xpub = xpub_header(xtype) + chr(depth) + fingerprint + child_number + c + cK
|
||||
return EncodeBase58Check(xpub)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -241,7 +241,7 @@ class Xpub:
|
|||
|
||||
@classmethod
|
||||
def get_pubkey_from_xpub(self, xpub, sequence):
|
||||
_, _, _, c, cK = deserialize_xpub(xpub)
|
||||
_, _, _, _, c, cK = deserialize_xpub(xpub)
|
||||
for i in sequence:
|
||||
cK, c = CKD_pub(cK, c, i)
|
||||
return cK.encode('hex')
|
||||
|
|
@ -298,7 +298,7 @@ class BIP32_KeyStore(Deterministic_KeyStore, Xpub):
|
|||
|
||||
def check_password(self, password):
|
||||
xprv = pw_decode(self.xprv, password)
|
||||
if deserialize_xprv(xprv)[3] != deserialize_xpub(self.xpub)[3]:
|
||||
if deserialize_xprv(xprv)[4] != deserialize_xpub(self.xpub)[4]:
|
||||
raise InvalidPassword()
|
||||
|
||||
def update_password(self, old_password, new_password):
|
||||
|
|
@ -322,14 +322,14 @@ class BIP32_KeyStore(Deterministic_KeyStore, Xpub):
|
|||
self.xprv = xprv
|
||||
self.xpub = bitcoin.xpub_from_xprv(xprv)
|
||||
|
||||
def add_xprv_from_seed(self, bip32_seed, derivation):
|
||||
xprv, xpub = bip32_root(bip32_seed)
|
||||
def add_xprv_from_seed(self, bip32_seed, xtype, derivation):
|
||||
xprv, xpub = bip32_root(bip32_seed, xtype)
|
||||
xprv, xpub = bip32_private_derivation(xprv, "m/", derivation)
|
||||
self.add_xprv(xprv)
|
||||
|
||||
def get_private_key(self, sequence, password):
|
||||
xprv = self.get_master_private_key(password)
|
||||
_, _, _, c, k = deserialize_xprv(xprv)
|
||||
_, _, _, _, c, k = deserialize_xprv(xprv)
|
||||
pk = bip32_private_key(sequence, k, c)
|
||||
return pk
|
||||
|
||||
|
|
@ -622,20 +622,6 @@ def is_old_mpk(mpk):
|
|||
return False
|
||||
return len(mpk) == 128
|
||||
|
||||
def is_xpub(text):
|
||||
try:
|
||||
deserialize_xpub(text)
|
||||
return True
|
||||
except:
|
||||
return False
|
||||
|
||||
def is_xprv(text):
|
||||
try:
|
||||
deserialize_xprv(text)
|
||||
return True
|
||||
except:
|
||||
return False
|
||||
|
||||
def is_address_list(text):
|
||||
parts = text.split()
|
||||
return bool(parts) and all(bitcoin.is_address(x) for x in parts)
|
||||
|
|
@ -669,7 +655,8 @@ def from_seed(seed, passphrase):
|
|||
keystore.add_seed(seed)
|
||||
keystore.passphrase = passphrase
|
||||
bip32_seed = Mnemonic.mnemonic_to_seed(seed, passphrase)
|
||||
keystore.add_xprv_from_seed(bip32_seed, "m/")
|
||||
xtype = 0 if t == 'standard' else 1
|
||||
keystore.add_xprv_from_seed(bip32_seed, xtype, "m/")
|
||||
return keystore
|
||||
|
||||
def from_private_key_list(text):
|
||||
|
|
|
|||
|
|
@ -1516,6 +1516,7 @@ class Simple_Wallet(Abstract_Wallet):
|
|||
|
||||
def load_keystore(self):
|
||||
self.keystore = load_keystore(self.storage, 'keystore')
|
||||
self.xpub_type = deserialize_xpub(self.keystore.xpub)[0]
|
||||
|
||||
def get_pubkey(self, c, i):
|
||||
pubkey_list = self.change_pubkeys if c else self.receiving_pubkeys
|
||||
|
|
@ -1622,26 +1623,28 @@ 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)
|
||||
def pubkeys_to_address(self, pubkey):
|
||||
redeem_script = self.pubkeys_to_redeem_script(pubkey)
|
||||
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):
|
||||
class Standard_Wallet(Simple_Deterministic_Wallet):
|
||||
wallet_type = 'standard'
|
||||
|
||||
def pubkeys_to_redeem_script(self, pubkeys):
|
||||
if self.xpub_type == 1:
|
||||
return transaction.segwit_script(pubkey)
|
||||
|
||||
def pubkeys_to_address(self, pubkey):
|
||||
if self.xpub_type == 0:
|
||||
return bitcoin.public_key_to_p2pkh(pubkey.decode('hex'))
|
||||
elif self.xpub_type == 1 and TESTNET:
|
||||
redeem_script = self.pubkeys_to_redeem_script(pubkeys)
|
||||
return bitcoin.hash160_to_p2sh(hash_160(redeem_script.decode('hex')))
|
||||
else:
|
||||
raise NotImplementedError()
|
||||
|
||||
class Segwit_Wallet(Simple_Deterministic_Wallet, P2SH):
|
||||
wallet_type = 'segwit'
|
||||
|
||||
def pubkeys_to_redeem_script(self, pubkey):
|
||||
return transaction.segwit_script(pubkey)
|
||||
|
||||
|
||||
|
||||
|
|
@ -1736,8 +1739,7 @@ wallet_constructors = {
|
|||
'standard': Standard_Wallet,
|
||||
'old': Standard_Wallet,
|
||||
'xpub': Standard_Wallet,
|
||||
'imported': Imported_Wallet,
|
||||
'segwit': Segwit_Wallet
|
||||
'imported': Imported_Wallet
|
||||
}
|
||||
|
||||
def register_constructor(wallet_type, constructor):
|
||||
|
|
|
|||
|
|
@ -285,19 +285,16 @@ def get_user_id(storage):
|
|||
return long_id, short_id
|
||||
|
||||
def make_xpub(xpub, s):
|
||||
_, _, _, c, cK = deserialize_xpub(xpub)
|
||||
version, _, _, _, c, cK = deserialize_xpub(xpub)
|
||||
cK2, c2 = bitcoin._CKD_pub(cK, c, s)
|
||||
xpub2 = ("0488B21E" + "00" + "00000000" + "00000000").decode("hex") + c2 + cK2
|
||||
return EncodeBase58Check(xpub2)
|
||||
|
||||
return bitcoin.serialize_xpub(version, c2, cK2)
|
||||
|
||||
def make_billing_address(wallet, num):
|
||||
long_id, short_id = wallet.get_user_id()
|
||||
xpub = make_xpub(billing_xpub, long_id)
|
||||
_, _, _, c, cK = deserialize_xpub(xpub)
|
||||
version, _, _, _, c, cK = deserialize_xpub(xpub)
|
||||
cK, c = bitcoin.CKD_pub(cK, c, num)
|
||||
address = public_key_to_bc_address( cK )
|
||||
return address
|
||||
return bitcoin.public_key_to_p2pkh(cK)
|
||||
|
||||
|
||||
class TrustedCoinPlugin(BasePlugin):
|
||||
|
|
@ -524,7 +521,7 @@ class TrustedCoinPlugin(BasePlugin):
|
|||
challenge = r.get('challenge')
|
||||
message = 'TRUSTEDCOIN CHALLENGE: ' + challenge
|
||||
def f(xprv):
|
||||
_, _, _, c, k = deserialize_xprv(xprv)
|
||||
_, _, _, _, c, k = deserialize_xprv(xprv)
|
||||
pk = bip32_private_key([0, 0], k, c)
|
||||
key = regenerate_key(pk)
|
||||
compressed = is_compressed(pk)
|
||||
|
|
|
|||
Loading…
Reference in New Issue