def test_streams(self):
m0 = BIP32Node.from_master_secret(b"foo bar baz")
pm0 = m0.public_copy()
self.assertEqual(m0.hwif(), pm0.hwif())
m1 = m0.subkey()
pm1 = pm0.subkey()
for i in range(4):
m = m1.subkey(i=i)
pm = pm1.subkey(i=i)
self.assertEqual(m.hwif(), pm.hwif())
self.assertEqual(m.address(), pm.address())
m2 = key_from_text(m.hwif(as_private=True))
m3 = m2.public_copy()
self.assertEqual(m.hwif(as_private=True), m2.hwif(as_private=True))
self.assertEqual(m.hwif(), m3.hwif())
print(m.hwif(as_private=True))
for j in range(2):
k = m.subkey(i=j)
k2 = key_from_text(k.hwif(as_private=True))
k3 = key_from_text(k.hwif())
k4 = k.public_copy()
self.assertEqual(k.hwif(as_private=True),
k2.hwif(as_private=True))
self.assertEqual(k.hwif(), k2.hwif())
self.assertEqual(k.hwif(), k3.hwif())
self.assertEqual(k.hwif(), k4.hwif())
print(" %s %s" % (k.address(), k.wif()))
def test_initial_key(self):
RECEIVING_ADDRESSES = [
"1LDkC1H438qSnJLHCYkQ3WTZQkSEwoYGHc",
"12mENAcc8ZhZbR6hv7LGm3jV7PwbYeF8Xk",
"1A3NpABFd6YHvwr1ti1r8brU3BzQuV2Nr4",
"1Gn6nWAoZrpmtV9zuNbyivWvRBpcygWaQX",
"1M5i5P3DhtDbnvSTfmnUbcrTVgF8GDWQW9"
]
CHANGE_ADDRESSES = [
"1iiAbyBTh1J69UzD1JcrfW8JSVJ9ve9gT",
"146wnqmsQNYCZ6AXRCqLkzZyGM1ZU6nr3F",
"1Mwexajvia3s8AcaGUkyEg9ZZJPJeTbKTZ"
]
wallet = ElectrumWallet(generator=secp256k1_generator,
initial_key="00000000000000000000000000000001")
for idx, address in enumerate(RECEIVING_ADDRESSES):
subkey = wallet.subkey("%s/0" % idx)
calculated_address = subkey.address()
self.assertEqual(address, calculated_address)
wif = subkey.wif()
key = key_from_text(wif)
self.assertEqual(key.address(use_uncompressed=True), address)
for idx, address in enumerate(CHANGE_ADDRESSES):
subkey = wallet.subkey("%s/1" % idx)
calculated_address = subkey.address()
self.assertEqual(address, calculated_address)
wif = subkey.wif()
key = key_from_text(wif)
self.assertEqual(key.address(use_uncompressed=True), address)
def test_streams(self):
m0 = BIP32Node.from_master_secret(b"foo bar baz")
pm0 = m0.public_copy()
self.assertEqual(m0.hwif(), pm0.hwif())
m1 = m0.subkey()
pm1 = pm0.subkey()
for i in range(4):
m = m1.subkey(i=i)
pm = pm1.subkey(i=i)
self.assertEqual(m.hwif(), pm.hwif())
self.assertEqual(m.address(), pm.address())
m2 = key_from_text(m.hwif(as_private=True))
m3 = m2.public_copy()
self.assertEqual(m.hwif(as_private=True), m2.hwif(as_private=True))
self.assertEqual(m.hwif(), m3.hwif())
print(m.hwif(as_private=True))
for j in range(2):
k = m.subkey(i=j)
k2 = key_from_text(k.hwif(as_private=True))
k3 = key_from_text(k.hwif())
k4 = k.public_copy()
self.assertEqual(k.hwif(as_private=True), k2.hwif(as_private=True))
self.assertEqual(k.hwif(), k2.hwif())
self.assertEqual(k.hwif(), k3.hwif())
self.assertEqual(k.hwif(), k4.hwif())
print(" %s %s" % (k.address(), k.wif()))
def test_initial_key(self):
RECEIVING_ADDRESSES = [
"1LDkC1H438qSnJLHCYkQ3WTZQkSEwoYGHc",
"12mENAcc8ZhZbR6hv7LGm3jV7PwbYeF8Xk",
"1A3NpABFd6YHvwr1ti1r8brU3BzQuV2Nr4",
"1Gn6nWAoZrpmtV9zuNbyivWvRBpcygWaQX",
"1M5i5P3DhtDbnvSTfmnUbcrTVgF8GDWQW9"
]
CHANGE_ADDRESSES = [
"1iiAbyBTh1J69UzD1JcrfW8JSVJ9ve9gT",
"146wnqmsQNYCZ6AXRCqLkzZyGM1ZU6nr3F",
"1Mwexajvia3s8AcaGUkyEg9ZZJPJeTbKTZ"
]
wallet = ElectrumWallet(generator=secp256k1_generator, initial_key="00000000000000000000000000000001")
for idx, address in enumerate(RECEIVING_ADDRESSES):
subkey = wallet.subkey("%s/0" % idx)
calculated_address = subkey.address()
self.assertEqual(address, calculated_address)
wif = subkey.wif()
key = key_from_text(wif)
self.assertEqual(key.address(use_uncompressed=True), address)
for idx, address in enumerate(CHANGE_ADDRESSES):
subkey = wallet.subkey("%s/1" % idx)
calculated_address = subkey.address()
self.assertEqual(address, calculated_address)
wif = subkey.wif()
key = key_from_text(wif)
self.assertEqual(key.address(use_uncompressed=True), address)
def test_repr(self):
key = XTNKey(secret_exponent=273)
address = key.address()
pub_k = key_from_text(address, networks=[BitcoinTestnet])
self.assertEqual(repr(pub_k), '<mhDVBkZBWLtJkpbszdjZRkH1o5RZxMwxca>')
wif = key.wif()
priv_k = key_from_text(wif, networks=[BitcoinTestnet])
self.assertEqual(
repr(priv_k),
'private_for <XTNSEC:0264e1b1969f9102977691a40431b0b672055dcf31163897d996434420e6c95dc9>')
def test_repr(self):
Key = BitcoinTestnet.ui._key_class
key = Key(secret_exponent=273)
wallet = XTNBIP32Node.from_master_secret(bytes(key.wif().encode('ascii')))
address = wallet.address()
pub_k = key_from_text(address, networks=[BitcoinTestnet])
self.assertEqual(repr(pub_k), '<myb5gZNXePNf2E2ksrjnHRFCwyuvt7oEay>')
wif = wallet.wif()
priv_k = key_from_text(wif, networks=[BitcoinTestnet])
self.assertEqual(repr(priv_k),
'private_for <XTNSEC:03ad094b1dc9fdce5d3648ca359b4e210a89d049532fdd39d9ccdd8ca393ac82f4>')
def test_repr(self):
key = XTNKey(secret_exponent=273, generator=secp256k1_generator)
address = key.address()
pub_k = key_from_text(address)
self.assertEqual(repr(pub_k), '<mhDVBkZBWLtJkpbszdjZRkH1o5RZxMwxca>')
wif = key.wif()
priv_k = key_from_text(wif)
self.assertEqual(
repr(priv_k),
'private_for <XTNSEC:0264e1b1969f9102977691a40431b0b672055dcf31163897d996434420e6c95dc9>'
)
def test_p2sh_multisig_sequential_signing(self):
raw_scripts = [
h2b("52210234abcffd2e80ad01c2ec0276ad02682808169c6fafdd25ebfb60703df272b461"
"2102e5baaafff8094e4d77ce8b009d5ebc3de9110085ebd3d96e50cc7ce70faf175221"
"0316ee25e80eb6e6fc734d9c86fa580cbb9c4bfd94a19f0373a22353ececd4db6853ae"
)
]
spendable = {
'script_hex':
'a914c4ed4de526461e3efbb79c8b688a6f9282c0464687',
'does_seem_spent':
0,
'block_index_spent':
0,
'coin_value':
10000,
'block_index_available':
0,
'tx_out_index':
0,
'tx_hash_hex':
'0ca152ba6b88db87a7ef1afd24554102aca1ab86cf2c10ccbc374472145dc943'
}
key_1 = key_from_text(
'Kz6pytJCigYHeMsGLmfHQPJhN5og2wpeSVrU43xWwgHLCAvpsprh')
key_2 = key_from_text(
'Kz7NHgX7MBySA3RSKj9GexUSN6NepEDoPNugSPr5absRDoKgn2dT')
for ordered_keys in [(key_1, key_2), (key_2, key_1)]:
txs_in = [
TxIn(previous_hash=h2b(
'43c95d14724437bccc102ccf86aba1ac02415524fd1aefa787db886bba52a10c'
),
previous_index=0)
]
txs_out = [
TxOut(10000,
script_for_address('3KeGeLFmsbmbVdeMLrWp7WYKcA3tdsB4AR'))
]
unspents = [Spendable.from_dict(spendable)]
tx = Tx(version=DEFAULT_VERSION,
txs_in=txs_in,
txs_out=txs_out,
unspents=unspents)
for key in ordered_keys:
self.assertEqual(tx.bad_solution_count(), 1)
p2sh_lookup = build_p2sh_lookup(raw_scripts)
tx.sign(build_hash160_lookup([key.secret_exponent()],
[secp256k1_generator]),
p2sh_lookup=p2sh_lookup)
self.assertEqual(tx.bad_solution_count(), 0)
def do_test(exp_hex, wif, c_wif, public_pair_sec, c_public_pair_sec,
address_b58, c_address_b58):
secret_exponent = int(exp_hex, 16)
sec = h2b(public_pair_sec)
c_sec = h2b(c_public_pair_sec)
keys_wif = [
Key(secret_exponent=secret_exponent,
generator=secp256k1_generator),
key_from_text(wif),
key_from_text(c_wif),
]
key_sec = Key.from_sec(sec, secp256k1_generator)
key_sec_c = Key.from_sec(c_sec, secp256k1_generator)
keys_sec = [key_sec, key_sec_c]
for key in keys_wif:
self.assertEqual(key.secret_exponent(), secret_exponent)
self.assertEqual(key.public_copy().secret_exponent(), None)
repr(key)
if key._prefer_uncompressed:
self.assertEqual(key.wif(), wif)
else:
self.assertEqual(key.wif(), c_wif)
self.assertEqual(key.wif(use_uncompressed=True), wif)
self.assertEqual(key.wif(use_uncompressed=False), c_wif)
for key in keys_wif + keys_sec:
if key._prefer_uncompressed:
self.assertEqual(key.sec(), sec)
else:
self.assertEqual(key.sec(), c_sec)
self.assertEqual(key.sec(use_uncompressed=True), sec)
self.assertEqual(key.sec(use_uncompressed=False), c_sec)
if key._prefer_uncompressed:
self.assertEqual(key.address(), address_b58)
else:
self.assertEqual(key.address(), c_address_b58)
self.assertEqual(key.address(use_uncompressed=False),
c_address_b58)
self.assertEqual(key.address(use_uncompressed=True),
address_b58)
key_pub = key_from_text(address_b58)
self.assertEqual(key_pub.address(), address_b58)
self.assertEqual(key_pub.address(use_uncompressed=True), None)
self.assertEqual(key_pub.address(use_uncompressed=False), None)
def test_master_public_and_private(self):
# these addresses were generated by hand using electrum with a master public key
# corresponding to secret exponent 1
RECEIVING_ADDRESSES = [
"1AYPdHLna6bKFUbeXoAEVbaXUxifUwCMay",
"13UeuWJba5epizAKyfCfiFKY5Kbxfdxe7B",
"19f6KJUTL5AGBRvLBGiL6Zpcx53QA7zaKT",
"1Cm33VuSkoUETwx5nsF1wgmGqYwJZxpZdY",
"14Z6ErkETixQMUeivsYbrdoUFns2J1iSct",
]
CHANGE_ADDRESSES = [
"1JVYsmjrqSy1BKvo1gYpNjX7AYea74nQYe",
"1Cc7itfQaDqZK3vHYphFsySujQjBNba8mw",
"15wrXvrAnyv3usGeQRohnnZ8tz9XAekbag",
"1MnWCEjE5YiZpZrkP8HcXEeDqwg43RxLwu",
"1Fgyp3PUx9AAg8yJe1zGXHP5dVC6i1tXbs",
"12XTLd4u9jeqw4egLAUhoKLxHARCdKWkty"
]
k = Key(secret_exponent=1, generator=secp256k1_generator)
master_public_key = k.sec(use_uncompressed=True)[1:]
wallet = ElectrumWallet(generator=secp256k1_generator,
master_public_key=master_public_key)
for idx, address in enumerate(RECEIVING_ADDRESSES):
subkey = wallet.subkey("%s/0" % idx)
calculated_address = subkey.address()
self.assertEqual(address, calculated_address)
for idx, address in enumerate(CHANGE_ADDRESSES):
subkey = wallet.subkey("%s/1" % idx)
calculated_address = subkey.address()
self.assertEqual(address, calculated_address)
wallet = ElectrumWallet(generator=secp256k1_generator,
master_private_key=1)
for idx, address in enumerate(RECEIVING_ADDRESSES):
subkey = wallet.subkey("%s/0" % idx)
calculated_address = subkey.address()
self.assertEqual(address, calculated_address)
wif = subkey.wif()
key = key_from_text(wif)
self.assertEqual(key.address(use_uncompressed=True), address)
for idx, address in enumerate(CHANGE_ADDRESSES):
subkey = wallet.subkey("%s/1" % idx)
calculated_address = subkey.address()
self.assertEqual(address, calculated_address)
wif = subkey.wif()
key = key_from_text(wif)
self.assertEqual(key.address(use_uncompressed=True), address)
def test_sign_bitcoind_partially_signed_2_of_2(self):
# Finish signing a 2 of 2 transaction, that already has one signature signed by bitcoind
# This tx can be found on testnet3 blockchain
# txid: 9618820d7037d2f32db798c92665231cd4599326f5bd99cb59d0b723be2a13a2
raw_script = (
"522103e33b41f5ed67a77d4c4c54b3e946bd30d15b8f66e42cb29fde059c168851165521"
"02b92cb20a9fb1eb9656a74eeb7387636cf64cdf502ff50511830328c1b479986452ae"
)
p2sh_lookup = build_p2sh_lookup([h2b(raw_script)])
partially_signed_raw_tx = (
"010000000196238f11a5fd3ceef4efd5a186a7e6b9217d900418e72aca917cd6a6e634"
"e74100000000910047304402201b41b471d9dd93cf97eed7cfc39a5767a546f6bfbf3e"
"0c91ff9ad23ab9770f1f02205ce565666271d055be1f25a7e52e34cbf659f6c70770ff"
"59bd783a6fcd1be3dd0147522103e33b41f5ed67a77d4c4c54b3e946bd30d15b8f66e4"
"2cb29fde059c16885116552102b92cb20a9fb1eb9656a74eeb7387636cf64cdf502ff5"
"0511830328c1b479986452aeffffffff01a0bb0d00000000001976a9143b3beefd6f78"
"02fa8706983a76a51467bfa36f8b88ac00000000")
tx = Tx.from_hex(partially_signed_raw_tx)
tx_out = TxOut(1000000,
h2b("a914a10dfa21ee8c33b028b92562f6fe04e60563d3c087"))
tx.set_unspents([tx_out])
key = key_from_text(
"cThRBRu2jAeshWL3sH3qbqdq9f4jDiDbd1SVz4qjTZD2xL1pdbsx")
hash160_lookup = build_hash160_lookup([key.secret_exponent()],
[secp256k1_generator])
self.assertEqual(tx.bad_solution_count(), 1)
tx.sign(hash160_lookup=hash160_lookup, p2sh_lookup=p2sh_lookup)
self.assertEqual(tx.bad_solution_count(), 0)
self.assertEqual(
tx.id(),
"9618820d7037d2f32db798c92665231cd4599326f5bd99cb59d0b723be2a13a2")
def test_parse_electrum_seed(self):
key = key_from_text("E:00000000000000000000000000000001", networks=NETWORKS)
self.assertEqual(
key.secret_exponent(), 0x2ccdb632d4630c8e5a417858f70876afe5585c15b1c0940771af9ac160201b1d)
self.assertEqual(key.address(), "16e8FARWaEo7Cf2rYxzr8Lg3S8JP2dwBxh")
subkey = key.subkey("1")
self.assertEqual(subkey.wif(), "5KYqyRxoMGnwsXfEFWtVifAKTzU9RcAZu1hme6GLMECKdWHybns")
def __init__(self, mainnet, dashrpc):
self.dashrpc = dashrpc
self.mainnet = mainnet
self._init_state_dir(os.path.join(DASHVEND_DIR, 'state'))
self.key = key_from_text(mainnet and BIP32_MAINNET_SEED
or BIP32_TESTNET_SEED)
self._init_next_address()
def test_master_public_and_private(self):
# these addresses were generated by hand using electrum with a master public key
# corresponding to secret exponent 1
RECEIVING_ADDRESSES = [
"1AYPdHLna6bKFUbeXoAEVbaXUxifUwCMay",
"13UeuWJba5epizAKyfCfiFKY5Kbxfdxe7B",
"19f6KJUTL5AGBRvLBGiL6Zpcx53QA7zaKT",
"1Cm33VuSkoUETwx5nsF1wgmGqYwJZxpZdY",
"14Z6ErkETixQMUeivsYbrdoUFns2J1iSct",
]
CHANGE_ADDRESSES = [
"1JVYsmjrqSy1BKvo1gYpNjX7AYea74nQYe",
"1Cc7itfQaDqZK3vHYphFsySujQjBNba8mw",
"15wrXvrAnyv3usGeQRohnnZ8tz9XAekbag",
"1MnWCEjE5YiZpZrkP8HcXEeDqwg43RxLwu",
"1Fgyp3PUx9AAg8yJe1zGXHP5dVC6i1tXbs",
"12XTLd4u9jeqw4egLAUhoKLxHARCdKWkty"
]
k = Key(secret_exponent=1, generator=secp256k1_generator)
master_public_key = k.sec(use_uncompressed=True)[1:]
wallet = ElectrumWallet(generator=secp256k1_generator, master_public_key=master_public_key)
for idx, address in enumerate(RECEIVING_ADDRESSES):
subkey = wallet.subkey("%s/0" % idx)
calculated_address = subkey.address()
self.assertEqual(address, calculated_address)
for idx, address in enumerate(CHANGE_ADDRESSES):
subkey = wallet.subkey("%s/1" % idx)
calculated_address = subkey.address()
self.assertEqual(address, calculated_address)
wallet = ElectrumWallet(generator=secp256k1_generator, master_private_key=1)
for idx, address in enumerate(RECEIVING_ADDRESSES):
subkey = wallet.subkey("%s/0" % idx)
calculated_address = subkey.address()
self.assertEqual(address, calculated_address)
wif = subkey.wif()
key = key_from_text(wif)
self.assertEqual(key.address(use_uncompressed=True), address)
for idx, address in enumerate(CHANGE_ADDRESSES):
subkey = wallet.subkey("%s/1" % idx)
calculated_address = subkey.address()
self.assertEqual(address, calculated_address)
wif = subkey.wif()
key = key_from_text(wif)
self.assertEqual(key.address(use_uncompressed=True), address)
def test_parse_bip32_pub(self):
key = key_from_text("xpub661MyMwAqRbcFVF9ULcqLdsEa5WnCCugQAcgNd9iEMQ31tgH6u4"
"DLQWoQayvtSVYFvXz2vPPpbXE1qpjoUFidhjFj82pVShWu9curWmb2zy", networks=NETWORKS)
self.assertEqual(key.secret_exponent(), None)
self.assertEqual(key.address(), "19Vqc8uLTfUonmxUEZac7fz1M5c5ZZbAii")
self.assertEqual(key.address(use_uncompressed=True), "1MwkRkogzBRMehBntgcq2aJhXCXStJTXHT")
subkey = key.subkey_for_path("0")
self.assertEqual(subkey.address(), "1NV3j6NgeAkWBytXiQkWxMFLBtTdbef1rp")
def do_test(exp_hex, wif, c_wif, public_pair_sec, c_public_pair_sec, address_b58, c_address_b58):
secret_exponent = int(exp_hex, 16)
sec = h2b(public_pair_sec)
c_sec = h2b(c_public_pair_sec)
keys_wif = [
Key(secret_exponent=secret_exponent, generator=secp256k1_generator),
key_from_text(wif),
key_from_text(c_wif),
]
key_sec = Key.from_sec(sec, secp256k1_generator)
key_sec_c = Key.from_sec(c_sec, secp256k1_generator)
keys_sec = [key_sec, key_sec_c]
for key in keys_wif:
self.assertEqual(key.secret_exponent(), secret_exponent)
self.assertEqual(key.public_copy().secret_exponent(), None)
repr(key)
if key._prefer_uncompressed:
self.assertEqual(key.wif(), wif)
else:
self.assertEqual(key.wif(), c_wif)
self.assertEqual(key.wif(use_uncompressed=True), wif)
self.assertEqual(key.wif(use_uncompressed=False), c_wif)
for key in keys_wif + keys_sec:
if key._prefer_uncompressed:
self.assertEqual(key.sec(), sec)
else:
self.assertEqual(key.sec(), c_sec)
self.assertEqual(key.sec(use_uncompressed=True), sec)
self.assertEqual(key.sec(use_uncompressed=False), c_sec)
if key._prefer_uncompressed:
self.assertEqual(key.address(), address_b58)
else:
self.assertEqual(key.address(), c_address_b58)
self.assertEqual(key.address(use_uncompressed=False), c_address_b58)
self.assertEqual(key.address(use_uncompressed=True), address_b58)
key_pub = key_from_text(address_b58)
self.assertEqual(key_pub.address(), address_b58)
self.assertEqual(key_pub.address(use_uncompressed=True), None)
self.assertEqual(key_pub.address(use_uncompressed=False), None)
def test_parse_bip32_prv_xtn(self):
key = key_from_text("tprv8ZgxMBicQKsPdpQD2swL99YVLB6W2GDqNVcCSfAZ9zMXvh6DYj5iJMZmUVrF66"
"x7uXBDJSunexZjAtFLtd89iLTWGCEpBdBxs7GTBnEksxV", networks=NETWORKS)
self.assertEqual(
key.secret_exponent(), 0x91880b0e3017ba586b735fe7d04f1790f3c46b818a2151fb2def5f14dd2fd9c3)
self.assertEqual(key.address(), "mp1nuBzKGgv4ZtS5x8YywbCLD5CnVfT7hV")
self.assertEqual(key.address(use_uncompressed=True), "n2ThiotfoCrcRofQcFbCrVX2PC89s2KUjh")
subkey = key.subkey_for_path("0")
self.assertEqual(subkey.address(), "n31129TfTCBky6N9RyitnGTf3t4LYwCV6A")
def d():
hwif = 'xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j'
to_sign = unhexlify(
'4554813e91f3d5be790c7c608f80b2b00f3ea77512d49039e9e3dc45f89e2f01')
priv_key = key_from_text(hwif)
sig = priv_key.sign(to_sign)
r, s = sigdecode_der(sig)
print(r)
print(s)
def test_parse_bip32_prv(self):
key = key_from_text("xprv9s21ZrQH143K31AgNK5pyVvW23gHnkBq2wh5aEk6g1s496M8ZMjx"
"ncCKZKgb5jZoY5eSJMJ2Vbyvi2hbmQnCuHBujZ2WXGTux1X2k9Krdtq", networks=NETWORKS)
self.assertEqual(
key.secret_exponent(), 0x91880b0e3017ba586b735fe7d04f1790f3c46b818a2151fb2def5f14dd2fd9c3)
self.assertEqual(key.address(), "19Vqc8uLTfUonmxUEZac7fz1M5c5ZZbAii")
self.assertEqual(key.address(use_uncompressed=True), "1MwkRkogzBRMehBntgcq2aJhXCXStJTXHT")
subkey = key.subkey_for_path("0")
self.assertEqual(subkey.address(), "1NV3j6NgeAkWBytXiQkWxMFLBtTdbef1rp")
def test_parse_electrum_seed(self):
key = key_from_text("E:00000000000000000000000000000001")
self.assertEqual(
key.secret_exponent(),
0x2ccdb632d4630c8e5a417858f70876afe5585c15b1c0940771af9ac160201b1d)
self.assertEqual(key.address(), "16e8FARWaEo7Cf2rYxzr8Lg3S8JP2dwBxh")
subkey = key.subkey("1")
self.assertEqual(
subkey.wif(),
"5KYqyRxoMGnwsXfEFWtVifAKTzU9RcAZu1hme6GLMECKdWHybns")
def test_parse_bip32_pub(self):
key = key_from_text(
"xpub661MyMwAqRbcFVF9ULcqLdsEa5WnCCugQAcgNd9iEMQ31tgH6u4"
"DLQWoQayvtSVYFvXz2vPPpbXE1qpjoUFidhjFj82pVShWu9curWmb2zy")
self.assertEqual(key.secret_exponent(), None)
self.assertEqual(key.address(), "19Vqc8uLTfUonmxUEZac7fz1M5c5ZZbAii")
self.assertEqual(key.address(use_uncompressed=True),
"1MwkRkogzBRMehBntgcq2aJhXCXStJTXHT")
subkey = key.subkey_for_path("0")
self.assertEqual(subkey.address(),
"1NV3j6NgeAkWBytXiQkWxMFLBtTdbef1rp")
def key_found(arg, payables, key_iters, network):
try:
key = key_from_text(arg)
# TODO: check network
if key.wif() is None:
payables.append((network.ui.script_for_address(key.address()), 0))
return True
key_iters.append(iter([key.wif()]))
return True
except Exception:
pass
return False
def test_parse_bip32_prv(self):
key = key_from_text(
"xprv9s21ZrQH143K31AgNK5pyVvW23gHnkBq2wh5aEk6g1s496M8ZMjx"
"ncCKZKgb5jZoY5eSJMJ2Vbyvi2hbmQnCuHBujZ2WXGTux1X2k9Krdtq")
self.assertEqual(
key.secret_exponent(),
0x91880b0e3017ba586b735fe7d04f1790f3c46b818a2151fb2def5f14dd2fd9c3)
self.assertEqual(key.address(), "19Vqc8uLTfUonmxUEZac7fz1M5c5ZZbAii")
self.assertEqual(key.address(use_uncompressed=True),
"1MwkRkogzBRMehBntgcq2aJhXCXStJTXHT")
subkey = key.subkey_for_path("0")
self.assertEqual(subkey.address(),
"1NV3j6NgeAkWBytXiQkWxMFLBtTdbef1rp")
def test_parse_bip32_prv_xtn(self):
key = key_from_text(
"tprv8ZgxMBicQKsPdpQD2swL99YVLB6W2GDqNVcCSfAZ9zMXvh6DYj5iJMZmUVrF66"
"x7uXBDJSunexZjAtFLtd89iLTWGCEpBdBxs7GTBnEksxV")
self.assertEqual(
key.secret_exponent(),
0x91880b0e3017ba586b735fe7d04f1790f3c46b818a2151fb2def5f14dd2fd9c3)
self.assertEqual(key.address(), "mp1nuBzKGgv4ZtS5x8YywbCLD5CnVfT7hV")
self.assertEqual(key.address(use_uncompressed=True),
"n2ThiotfoCrcRofQcFbCrVX2PC89s2KUjh")
subkey = key.subkey_for_path("0")
self.assertEqual(subkey.address(),
"n31129TfTCBky6N9RyitnGTf3t4LYwCV6A")
def test_p2sh_multisig_sequential_signing(self):
raw_scripts = [h2b(
"52210234abcffd2e80ad01c2ec0276ad02682808169c6fafdd25ebfb60703df272b461"
"2102e5baaafff8094e4d77ce8b009d5ebc3de9110085ebd3d96e50cc7ce70faf175221"
"0316ee25e80eb6e6fc734d9c86fa580cbb9c4bfd94a19f0373a22353ececd4db6853ae")]
spendable = {'script_hex': 'a914c4ed4de526461e3efbb79c8b688a6f9282c0464687', 'does_seem_spent': 0,
'block_index_spent': 0, 'coin_value': 10000, 'block_index_available': 0, 'tx_out_index': 0,
'tx_hash_hex': '0ca152ba6b88db87a7ef1afd24554102aca1ab86cf2c10ccbc374472145dc943'}
key_1 = key_from_text('Kz6pytJCigYHeMsGLmfHQPJhN5og2wpeSVrU43xWwgHLCAvpsprh')
key_2 = key_from_text('Kz7NHgX7MBySA3RSKj9GexUSN6NepEDoPNugSPr5absRDoKgn2dT')
for ordered_keys in [(key_1, key_2), (key_2, key_1)]:
txs_in = [TxIn(previous_hash=h2b('43c95d14724437bccc102ccf86aba1ac02415524fd1aefa787db886bba52a10c'),
previous_index=0)]
txs_out = [TxOut(10000, script_for_address('3KeGeLFmsbmbVdeMLrWp7WYKcA3tdsB4AR'))]
unspents = [Spendable.from_dict(spendable)]
tx = Tx(version=DEFAULT_VERSION, txs_in=txs_in, txs_out=txs_out, unspents=unspents)
for key in ordered_keys:
self.assertEqual(tx.bad_signature_count(), 1)
p2sh_lookup = build_p2sh_lookup(raw_scripts)
tx.sign(build_hash160_lookup([key.secret_exponent()], [secp256k1_generator]), p2sh_lookup=p2sh_lookup)
self.assertEqual(tx.bad_signature_count(), 0)
def test_sign_bitcoind_partially_signed_2_of_2(self):
# Finish signing a 2 of 2 transaction, that already has one signature signed by bitcoind
# This tx can be found on testnet3 blockchain
# txid: 9618820d7037d2f32db798c92665231cd4599326f5bd99cb59d0b723be2a13a2
raw_script = ("522103e33b41f5ed67a77d4c4c54b3e946bd30d15b8f66e42cb29fde059c168851165521"
"02b92cb20a9fb1eb9656a74eeb7387636cf64cdf502ff50511830328c1b479986452ae")
p2sh_lookup = build_p2sh_lookup([h2b(raw_script)])
partially_signed_raw_tx = (
"010000000196238f11a5fd3ceef4efd5a186a7e6b9217d900418e72aca917cd6a6e634"
"e74100000000910047304402201b41b471d9dd93cf97eed7cfc39a5767a546f6bfbf3e"
"0c91ff9ad23ab9770f1f02205ce565666271d055be1f25a7e52e34cbf659f6c70770ff"
"59bd783a6fcd1be3dd0147522103e33b41f5ed67a77d4c4c54b3e946bd30d15b8f66e4"
"2cb29fde059c16885116552102b92cb20a9fb1eb9656a74eeb7387636cf64cdf502ff5"
"0511830328c1b479986452aeffffffff01a0bb0d00000000001976a9143b3beefd6f78"
"02fa8706983a76a51467bfa36f8b88ac00000000")
tx = Tx.from_hex(partially_signed_raw_tx)
tx_out = TxOut(1000000, h2b("a914a10dfa21ee8c33b028b92562f6fe04e60563d3c087"))
tx.set_unspents([tx_out])
key = key_from_text("cThRBRu2jAeshWL3sH3qbqdq9f4jDiDbd1SVz4qjTZD2xL1pdbsx")
hash160_lookup = build_hash160_lookup([key.secret_exponent()], [secp256k1_generator])
self.assertEqual(tx.bad_signature_count(), 1)
tx.sign(hash160_lookup=hash160_lookup, p2sh_lookup=p2sh_lookup)
self.assertEqual(tx.bad_signature_count(), 0)
self.assertEqual(tx.id(), "9618820d7037d2f32db798c92665231cd4599326f5bd99cb59d0b723be2a13a2")
def make_key(x):
try:
return key_from_text(x)
except Exception:
return None
def test_parse_address(self):
key = key_from_text("1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH")
self.assertEqual(key.address(), "1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH")
def change_prefix(address, new_prefix):
return b2a_hashed_base58(new_prefix + key_from_text(address).hash160())
def test_parse_electrum_master_private(self):
key = key_from_text("E:0000000000000000000000000000000000000000000000000000000000000001", networks=NETWORKS)
self.assertEqual(key.secret_exponent(), 1)
def test_parse_bad_address(self):
key = key_from_text("1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMW")
self.assertEqual(key, None)
def test_parse_wif(self):
key = key_from_text(
"KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn")
self.assertEqual(key.secret_exponent(), 1)
def test_parse_bad_bip32_prv(self):
key = key_from_text(
"xprv9s21ZrQH143K31AgNK5pyVvW23gHnkBq2wh5aEk6g1s496M8ZMjx"
"ncCKZKgb5jZoY5eSJMJ2Vbyvi2hbmQnCuHBujZ2WXGTux1X2k9Krdtr")
self.assertEqual(key, None)
def make_key(x):
try:
return key_from_text(x)
except Exception:
return None
def test_parse_wif(self):
key = key_from_text("KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn", networks=NETWORKS)
self.assertEqual(key.secret_exponent(), 1)
def test_parse_bad_wif(self):
key = key_from_text("KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWo", networks=NETWORKS)
self.assertEqual(key, None)
def get_addr_from_pub(self, account_xpub, address_number):
account_key = key_from_text(account_xpub, networks=[self._network])
address_key = account_key.subkey_for_path(f"0/{address_number}")
return self.get_address(address_key)
def test_parse_bad_address(self):
key = key_from_text("1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMW", networks=NETWORKS)
self.assertEqual(key, None)
def change_prefix(address, new_prefix):
return b2a_hashed_base58(new_prefix + key_from_text(address).hash160())
def test_parse_bad_wif(self):
key = key_from_text(
"KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWo")
self.assertEqual(key, None)
def test_parse_electrum_master_private(self):
key = key_from_text(
"E:0000000000000000000000000000000000000000000000000000000000000001"
)
self.assertEqual(key.secret_exponent(), 1)
def test_parse_bad_bip32_prv(self):
key = key_from_text("xprv9s21ZrQH143K31AgNK5pyVvW23gHnkBq2wh5aEk6g1s496M8ZMjx"
"ncCKZKgb5jZoY5eSJMJ2Vbyvi2hbmQnCuHBujZ2WXGTux1X2k9Krdtr", networks=NETWORKS)
self.assertEqual(key, None)
