def test_one_prvkey_multiple_addresses(self):
msg = "Paolo is afraid of ephemeral random numbers"
# Compressed WIF
wif = b"Kx45GeUBSMPReYQwgXiKhG9FzNXrnCeutJp4yjTd5kKxCitadm3C"
pubkey, network = pubkeyinfo_from_prvkey(wif)
address1 = p2pkh(pubkey, network)
address2 = p2wpkh_p2sh(pubkey, network)
address3 = p2wpkh(pubkey, network)
# sign with no address (or compressed P2PKH)
sig1 = bms.sign(msg, wif)
# True for Bitcoin Core
self.assertTrue(bms.verify(msg, address1, sig1))
# True for Electrum p2wpkh_p2sh
self.assertTrue(bms.verify(msg, address2, sig1))
# True for Electrum p2wpkh
self.assertTrue(bms.verify(msg, address3, sig1))
# sign with p2wpkh_p2sh address (BIP137)
sig2 = bms.sign(msg, wif, address2)
# False for Bitcoin Core
self.assertFalse(bms.verify(msg, address1, sig2))
# True for BIP137 p2wpkh_p2sh
self.assertTrue(bms.verify(msg, address2, sig2))
# False for BIP137 p2wpkh
self.assertFalse(bms.verify(msg, address3, sig2))
# sign with p2wpkh address (BIP137)
sig3 = bms.sign(msg, wif, address3)
# False for Bitcoin Core
self.assertFalse(bms.verify(msg, address1, sig3))
# False for BIP137 p2wpkh_p2sh
self.assertFalse(bms.verify(msg, address2, sig3))
# True for BIP137 p2wpkh
self.assertTrue(bms.verify(msg, address3, sig3))
# uncompressed WIF / P2PKH address
q, network, _ = prvkeyinfo_from_prvkey(wif)
wif2 = wif_from_prvkey(q, network, False)
pubkey, network = pubkeyinfo_from_prvkey(wif2)
address4 = p2pkh(pubkey, network)
# sign with uncompressed P2PKH
sig4 = bms.sign(msg, wif2, address4)
# False for Bitcoin Core compressed p2pkh
self.assertFalse(bms.verify(msg, address1, sig4))
# False for BIP137 p2wpkh_p2sh
self.assertFalse(bms.verify(msg, address2, sig4))
# False for BIP137 p2wpkh
self.assertFalse(bms.verify(msg, address3, sig4))
# True for Bitcoin Core uncompressed p2pkh
self.assertTrue(bms.verify(msg, address4, sig4))
self.assertRaises(ValueError, bms.sign, msg, wif2, address1)
self.assertRaises(ValueError, bms.sign, msg, wif, address4)
def test_address_from_wif() -> None:
q = 0x19E14A7B6A307F426A94F8114701E7C8E774E7F9A47E2C2035DB29A206321725
test_cases: List[Tuple[bool, str, str, str]] = [
(
False,
"mainnet",
"5J1geo9kcAUSM6GJJmhYRX1eZEjvos9nFyWwPstVziTVueRJYvW",
"1LPM8SZ4RQDMZymUmVSiSSvrDfj1UZY9ig",
),
(
True,
"mainnet",
"Kx621phdUCp6sgEXPSHwhDTrmHeUVrMkm6T95ycJyjyxbDXkr162",
"1HJC7kFvXHepkSzdc8RX6khQKkAyntdfkB",
),
(
False,
"testnet",
"91nKEXyJCPYaK9maw7bTJ7ZcCu6dy2gybvNtUWF1LTCYggzhZgy",
"mzuJRVe3ERecM6F6V4R6GN9B5fKiPC9HxF",
),
(
True,
"testnet",
"cNT1UjhUuGWN37hnmr754XxvPWwtAJTSq8bcCQ4pUrdxqxbA1iU1",
"mwp9QoLuLK65XZUFKhPtvfujBjmgkZnmPx",
),
]
for compressed, network, wif, address in test_cases:
assert wif.encode() == wif_from_prvkey(q, network, compressed)
assert prvkeyinfo_from_prvkey(wif) == (q, network, compressed)
b58 = p2pkh(wif)
assert b58 == address.encode()
_, payload, net, is_script = h160_from_b58address(b58)
assert net == network
assert not is_script
if compressed:
b32 = p2wpkh(wif)
assert (payload, network,
is_script) == witness_from_b32address(b32)[1:]
b = p2wpkh_p2sh(wif)
_, payload2, net, is_script = h160_from_b58address(b)
assert is_script
assert (hash160(b"\x00\x14" + payload), network) == (payload2, net)
else:
err_msg = "not a private or compressed public key: "
with pytest.raises(ValueError, match=err_msg):
p2wpkh(wif) # type: ignore
with pytest.raises(ValueError, match=err_msg):
p2wpkh_p2sh(wif) # type: ignore
def test_info_from_prvkey(self):
xprv = (
"xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiC"
"hkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi").encode()
xprv_str = xprv.decode("ascii")
xprv_dict = bip32.deserialize(xprv)
wif = wif_from_prvkey(xprv)
wif_str = wif.decode("ascii")
ref_tuple = (xprv_dict["q"], "mainnet", True)
# BIP32
self.assertEqual(ref_tuple, prvkeyinfo_from_prvkey(xprv, "mainnet"))
self.assertEqual(ref_tuple, prvkeyinfo_from_prvkey(xprv))
self.assertEqual(ref_tuple, prvkeyinfo_from_prvkey(xprv_str))
self.assertEqual(ref_tuple,
prvkeyinfo_from_prvkey(" " + xprv_str + " "))
self.assertEqual(ref_tuple, prvkeyinfo_from_prvkey(xprv_dict))
# Invalid decoded size: 6 bytes instead of 82
xpub = "notakey"
self.assertRaises(ValueError, prvkeyinfo_from_prvkey, xpub)
# prvkeyinfo_from_prvkey(xpub)
# xkey is not a private one
xpub = (
"xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2g"
"Z29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8").encode()
self.assertRaises(ValueError, prvkeyinfo_from_prvkey, xpub)
# prvkeyinfo_from_prvkey(xpub)
# xkey is not a private one
xpub_dict = bip32.deserialize(xpub)
self.assertRaises(ValueError, prvkeyinfo_from_prvkey, xpub_dict)
# prvkeyinfo_from_prvkey(xpub_dict)
# WIF keys (bytes or string)
self.assertEqual(ref_tuple, prvkeyinfo_from_prvkey(wif))
self.assertEqual(ref_tuple, prvkeyinfo_from_prvkey(wif_str))
self.assertEqual(ref_tuple,
prvkeyinfo_from_prvkey(" " + wif_str + " "))
sig3 = sign(msg, wif, address3)
print(f"rf3: {sig3[0]}")
print(f" r3: {hex(sig3[1]).upper()}")
print(f" s3: {hex(sig3[2]).upper()}")
bsmsig3 = encode(*sig3)
print("4. Serialized signature:")
print(bsmsig3.decode())
print("5. Verify signature")
print("Bitcoin Core p2pkh:", verify(msg, address1, sig3))
print("BIP137 p2wpkh_p2sh:", verify(msg, address2, sig3))
print("BIP137 p2wpkh :", verify(msg, address3, sig3))
# uncompressed WIF / P2PKH address
q, network, _ = prvkeyinfo_from_prvkey(wif)
wif2 = wif_from_prvkey(q, network, compressed=False)
print("\n1. Uncompressed WIF :", wif2.decode())
pubkey, network = pubkeyinfo_from_prvkey(wif2)
address4 = p2pkh(pubkey)
print("2. Uncompressed P2PKH address:", address4.decode())
print("3. Sign message with uncompressed p2pkh:")
sig4 = sign(msg, wif2, address4)
print(f"rf4: {sig4[0]}")
print(f" r4: {hex(sig4[1]).upper()}")
print(f" s4: {hex(sig4[2]).upper()}")
bsmsig4 = encode(*sig4)
print("4. Serialized signature:")
def test_one_prvkey_multiple_addresses() -> None:
msg = "Paolo is afraid of ephemeral random numbers"
# Compressed WIF
wif = b"Kx45GeUBSMPReYQwgXiKhG9FzNXrnCeutJp4yjTd5kKxCitadm3C"
addr_p2pkh_compressed = p2pkh(wif)
addr_p2wpkh_p2sh = p2wpkh_p2sh(wif)
addr_p2wpkh = p2wpkh(wif)
# sign with no address
sig1 = bms.sign(msg, wif)
# True for Bitcoin Core
bms.assert_as_valid(msg, addr_p2pkh_compressed, sig1)
assert bms.verify(msg, addr_p2pkh_compressed, sig1)
# True for Electrum p2wpkh_p2sh
bms.assert_as_valid(msg, addr_p2wpkh_p2sh, sig1)
assert bms.verify(msg, addr_p2wpkh_p2sh, sig1)
# True for Electrum p2wpkh
bms.assert_as_valid(msg, addr_p2wpkh, sig1)
assert bms.verify(msg, addr_p2wpkh, sig1)
# sign with no p2pkh address
sig1 = bms.sign(msg, wif, addr_p2pkh_compressed)
# True for Bitcoin Core
bms.assert_as_valid(msg, addr_p2pkh_compressed, sig1)
assert bms.verify(msg, addr_p2pkh_compressed, sig1)
# True for Electrum p2wpkh_p2sh
bms.assert_as_valid(msg, addr_p2wpkh_p2sh, sig1)
assert bms.verify(msg, addr_p2wpkh_p2sh, sig1)
# True for Electrum p2wpkh
bms.assert_as_valid(msg, addr_p2wpkh, sig1)
assert bms.verify(msg, addr_p2wpkh, sig1)
err_msg = "invalid recovery flag: "
# sign with p2wpkh_p2sh address (BIP137)
sig2 = bms.sign(msg, wif, addr_p2wpkh_p2sh)
# False for Bitcoin Core
with pytest.raises(BTClibValueError, match=err_msg):
bms.assert_as_valid(msg, addr_p2pkh_compressed, sig2)
assert not bms.verify(msg, addr_p2pkh_compressed, sig2)
# True for BIP137 p2wpkh_p2sh
bms.assert_as_valid(msg, addr_p2wpkh_p2sh, sig2)
assert bms.verify(msg, addr_p2wpkh_p2sh, sig2)
# False for BIP137 p2wpkh
with pytest.raises(BTClibValueError, match=err_msg):
bms.assert_as_valid(msg, addr_p2wpkh, sig2)
assert not bms.verify(msg, addr_p2wpkh, sig2)
# sign with p2wpkh address (BIP137)
sig3 = bms.sign(msg, wif, addr_p2wpkh)
# False for Bitcoin Core
with pytest.raises(BTClibValueError, match=err_msg):
bms.assert_as_valid(msg, addr_p2pkh_compressed, sig3)
assert not bms.verify(msg, addr_p2pkh_compressed, sig3)
# False for BIP137 p2wpkh_p2sh
with pytest.raises(BTClibValueError, match=err_msg):
bms.assert_as_valid(msg, addr_p2wpkh_p2sh, sig3)
assert not bms.verify(msg, addr_p2wpkh_p2sh, sig3)
# True for BIP137 p2wpkh
bms.assert_as_valid(msg, addr_p2wpkh, sig3)
assert bms.verify(msg, addr_p2wpkh, sig3)
# uncompressed WIF / p2pkh address
q, network, _ = prvkeyinfo_from_prvkey(wif)
wif2 = wif_from_prvkey(q, network, False)
addr_p2pkh_uncompressed = p2pkh(wif2)
# sign with uncompressed p2pkh
sig4 = bms.sign(msg, wif2, addr_p2pkh_uncompressed)
# False for Bitcoin Core compressed p2pkh
with pytest.raises(BTClibValueError, match="wrong p2pkh address: "):
bms.assert_as_valid(msg, addr_p2pkh_compressed, sig4)
assert not bms.verify(msg, addr_p2pkh_compressed, sig4)
# False for BIP137 p2wpkh_p2sh
# FIXME: puzzling error message
# it should have been "wrong p2wpkh-p2sh address: "
with pytest.raises(BTClibValueError, match="wrong p2pkh address: "):
bms.assert_as_valid(msg, addr_p2wpkh_p2sh, sig4)
assert not bms.verify(msg, addr_p2wpkh_p2sh, sig4)
# False for BIP137 p2wpkh
with pytest.raises(BTClibValueError, match=err_msg):
bms.assert_as_valid(msg, addr_p2wpkh, sig4)
assert not bms.verify(msg, addr_p2wpkh, sig4)
# True for Bitcoin Core uncompressed p2pkh
bms.assert_as_valid(msg, addr_p2pkh_uncompressed, sig4)
assert bms.verify(msg, addr_p2pkh_uncompressed, sig4)
# unrelated different wif
wif3 = b"KwdMAjGmerYanjeui5SHS7JkmpZvVipYvB2LJGU1ZxJwYvP98617"
addr_p2pkh_compressed = p2pkh(wif3)
addr_p2wpkh_p2sh = p2wpkh_p2sh(wif3)
addr_p2wpkh = p2wpkh(wif3)
# False for Bitcoin Core compressed p2pkh
with pytest.raises(BTClibValueError, match="wrong p2pkh address: "):
bms.assert_as_valid(msg, addr_p2pkh_compressed, sig1)
assert not bms.verify(msg, addr_p2pkh_compressed, sig1)
# False for BIP137 p2wpkh_p2sh
with pytest.raises(BTClibValueError, match="wrong p2wpkh-p2sh address: "):
bms.assert_as_valid(msg, addr_p2wpkh_p2sh, sig1)
assert not bms.verify(msg, addr_p2wpkh_p2sh, sig1)
# False for BIP137 p2wpkh
with pytest.raises(BTClibValueError, match="wrong p2wpkh address: "):
bms.assert_as_valid(msg, addr_p2wpkh, sig1)
assert not bms.verify(msg, addr_p2wpkh, sig1)
# FIXME: puzzling error message
err_msg = "not a private or compressed public key for mainnet: "
with pytest.raises(BTClibValueError, match=err_msg):
bms.sign(msg, wif2, addr_p2pkh_compressed)
err_msg = "mismatch between private key and address"
with pytest.raises(BTClibValueError, match=err_msg):
bms.sign(msg, wif, addr_p2pkh_uncompressed)
def test_wif_from_prvkey(self):
prvkey = "0C28FCA386C7A227600B2FE50B7CAE11EC86D3BF1FBE471BE89827E19D72AA1D"
test_vectors = [
[
"KwdMAjGmerYanjeui5SHS7JkmpZvVipYvB2LJGU1ZxJwYvP98617",
"mainnet", True
],
[
"cMzLdeGd5vEqxB8B6VFQoRopQ3sLAAvEzDAoQgvX54xwofSWj1fx",
"testnet", True
],
[
"5HueCGU8rMjxEXxiPuD5BDku4MkFqeZyd4dZ1jvhTVqvbTLvyTJ",
"mainnet", False
],
[
"91gGn1HgSap6CbU12F6z3pJri26xzp7Ay1VW6NHCoEayNXwRpu2",
"testnet", False
],
[
" KwdMAjGmerYanjeui5SHS7JkmpZvVipYvB2LJGU1ZxJwYvP98617",
"mainnet", True
],
[
"KwdMAjGmerYanjeui5SHS7JkmpZvVipYvB2LJGU1ZxJwYvP98617 ",
"mainnet", True
],
]
for v in test_vectors:
wif = wif_from_prvkey(prvkey, v[1], v[2])
self.assertEqual(v[0].strip(), wif.decode("ascii"))
q, network, compressed = prvkeyinfo_from_prvkey(v[0])
self.assertEqual(q, int(prvkey, 16))
self.assertEqual(network, v[1])
self.assertEqual(compressed, v[2])
# not a 32-bytes private key
badq = 33 * b"\x02"
self.assertRaises(ValueError, wif_from_prvkey, badq, "mainnet", True)
# wif_from_prvkey(badq, 'mainnet', True)
# private key not in (0, n)
badq = ec.n
self.assertRaises(ValueError, wif_from_prvkey, badq, "mainnet", True)
# wif_from_prvkey(badq, 'mainnet', True)
# Not a private key WIF: missing leading 0x80
payload = b"\x81" + badq.to_bytes(ec.nsize, "big")
badwif = b58encode(payload)
self.assertRaises(ValueError, prvkeyinfo_from_prvkey, badwif)
# prvkeyinfo_from_prvkey(badwif)
# Not a compressed WIF: missing trailing 0x01
payload = b"\x80" + badq.to_bytes(ec.nsize, "big") + b"\x00"
badwif = b58encode(payload)
self.assertRaises(ValueError, prvkeyinfo_from_prvkey, badwif)
# prvkeyinfo_from_prvkey(badwif)
# Not a WIF: wrong size (35)
payload = b"\x80" + badq.to_bytes(ec.nsize, "big") + b"\x01\x00"
badwif = b58encode(payload)
self.assertRaises(ValueError, prvkeyinfo_from_prvkey, badwif)
# prvkeyinfo_from_prvkey(badwif)
# Not a WIF: private key not in (0, n)
payload = b"\x80" + badq.to_bytes(ec.nsize, "big")
badwif = b58encode(payload)
self.assertRaises(ValueError, prvkeyinfo_from_prvkey, badwif)
def test_wif_from_prvkey() -> None:
prvkey = "0C28FCA386C7A227600B2FE50B7CAE11EC86D3BF1FBE471BE89827E19D72AA1D"
test_vectors: List[Tuple[str, str, bool]] = [
("KwdMAjGmerYanjeui5SHS7JkmpZvVipYvB2LJGU1ZxJwYvP98617", "mainnet", True),
("cMzLdeGd5vEqxB8B6VFQoRopQ3sLAAvEzDAoQgvX54xwofSWj1fx", "testnet", True),
("5HueCGU8rMjxEXxiPuD5BDku4MkFqeZyd4dZ1jvhTVqvbTLvyTJ", "mainnet", False),
("91gGn1HgSap6CbU12F6z3pJri26xzp7Ay1VW6NHCoEayNXwRpu2", "testnet", False),
(" KwdMAjGmerYanjeui5SHS7JkmpZvVipYvB2LJGU1ZxJwYvP98617", "mainnet", True),
("KwdMAjGmerYanjeui5SHS7JkmpZvVipYvB2LJGU1ZxJwYvP98617 ", "mainnet", True),
]
for v in test_vectors:
wif = wif_from_prvkey(prvkey, v[1], v[2])
# FIXME clarify decode("ascii") and encode("ascii") everywhere
assert v[0].strip() == wif.decode("ascii")
q, network, compressed = prvkeyinfo_from_prvkey(v[0])
assert q == int(prvkey, 16)
assert network == v[1]
assert compressed == v[2]
bad_q = ec.n.to_bytes(ec.nsize, "big")
with pytest.raises(ValueError, match="private key not in 1..n-1: "):
wif_from_prvkey(bad_q, "mainnet", True)
payload = b"\x80" + bad_q
badwif = b58encode(payload)
with pytest.raises(ValueError, match="not a private key: "):
prvkeyinfo_from_prvkey(badwif)
# not a private key: 33 bytes
bad_q = 33 * b"\x02"
with pytest.raises(ValueError, match="not a private key: "):
wif_from_prvkey(bad_q, "mainnet", True)
payload = b"\x80" + bad_q
badwif = b58encode(payload)
with pytest.raises(ValueError, match="not a private key: "):
prvkeyinfo_from_prvkey(badwif)
# Not a WIF: missing leading 0x80
good_q = 32 * b"\x02"
payload = b"\x81" + good_q
badwif = b58encode(payload)
with pytest.raises(ValueError, match="not a private key: "):
prvkeyinfo_from_prvkey(badwif)
# Not a compressed WIF: missing trailing 0x01
payload = b"\x80" + good_q + b"\x00"
badwif = b58encode(payload)
with pytest.raises(ValueError, match="not a private key: "):
prvkeyinfo_from_prvkey(badwif)
# Not a WIF: wrong size (35)
payload = b"\x80" + good_q + b"\x01\x00"
badwif = b58encode(payload)
with pytest.raises(ValueError, match="not a private key: "):
prvkeyinfo_from_prvkey(badwif)
def test_from_prvkey():
secp256r1 = CURVES["secp256r1"]
m_c = (q, "mainnet", True)
m_unc = (q, "mainnet", False)
t_c = (q, "testnet", True)
t_unc = (q, "testnet", False)
for prv_key in [q] + plain_prv_keys:
assert q == int_from_prvkey(prv_key)
assert q == int_from_prvkey(prv_key, secp256r1)
assert m_c == prvkeyinfo_from_prvkey(prv_key)
assert m_c == prvkeyinfo_from_prvkey(prv_key, "mainnet")
assert m_c == prvkeyinfo_from_prvkey(prv_key, "mainnet", compressed=True)
assert m_c == prvkeyinfo_from_prvkey(prv_key, compressed=True)
assert m_unc == prvkeyinfo_from_prvkey(prv_key, "mainnet", compressed=False)
assert m_unc == prvkeyinfo_from_prvkey(prv_key, compressed=False)
assert t_c == prvkeyinfo_from_prvkey(prv_key, "testnet")
assert t_c == prvkeyinfo_from_prvkey(prv_key, "testnet", compressed=True)
assert t_unc == prvkeyinfo_from_prvkey(prv_key, "testnet", compressed=False)
for prv_key in [xprv_dict] + compressed_prv_keys:
assert q == int_from_prvkey(prv_key)
with pytest.raises(ValueError):
int_from_prvkey(prv_key, secp256r1)
assert m_c == prvkeyinfo_from_prvkey(prv_key)
assert m_c == prvkeyinfo_from_prvkey(prv_key, "mainnet")
assert m_c == prvkeyinfo_from_prvkey(prv_key, "mainnet", compressed=True)
assert m_c == prvkeyinfo_from_prvkey(prv_key, compressed=True)
with pytest.raises(ValueError):
prvkeyinfo_from_prvkey(prv_key, "mainnet", compressed=False)
with pytest.raises(ValueError):
prvkeyinfo_from_prvkey(prv_key, compressed=False)
with pytest.raises(ValueError):
prvkeyinfo_from_prvkey(prv_key, "testnet")
with pytest.raises(ValueError):
prvkeyinfo_from_prvkey(prv_key, "testnet", compressed=True)
with pytest.raises(ValueError):
prvkeyinfo_from_prvkey(prv_key, "testnet", compressed=False)
for prv_key in uncompressed_prv_keys:
assert q == int_from_prvkey(prv_key)
with pytest.raises(ValueError):
int_from_prvkey(prv_key, secp256r1)
assert m_unc == prvkeyinfo_from_prvkey(prv_key)
assert m_unc == prvkeyinfo_from_prvkey(prv_key, "mainnet")
with pytest.raises(ValueError):
prvkeyinfo_from_prvkey(prv_key, "mainnet", compressed=True)
with pytest.raises(ValueError):
prvkeyinfo_from_prvkey(prv_key, compressed=True)
assert m_unc == prvkeyinfo_from_prvkey(prv_key, "mainnet", compressed=False)
assert m_unc == prvkeyinfo_from_prvkey(prv_key, compressed=False)
with pytest.raises(ValueError):
prvkeyinfo_from_prvkey(prv_key, "testnet")
with pytest.raises(ValueError):
prvkeyinfo_from_prvkey(prv_key, "testnet", compressed=True)
with pytest.raises(ValueError):
prvkeyinfo_from_prvkey(prv_key, "testnet", compressed=False)
for prv_key in [xprv_dict] + net_aware_prv_keys:
assert q == int_from_prvkey(prv_key)
with pytest.raises(ValueError):
int_from_prvkey(prv_key, secp256r1)
assert prvkeyinfo_from_prvkey(prv_key) in (m_c, m_unc)
assert prvkeyinfo_from_prvkey(prv_key, "mainnet") in (m_c, m_unc)
with pytest.raises(ValueError):
prvkeyinfo_from_prvkey(prv_key, "testnet")
for prv_key in [q] + net_unaware_prv_keys:
assert q == int_from_prvkey(prv_key)
assert q == int_from_prvkey(prv_key, secp256r1)
assert prvkeyinfo_from_prvkey(prv_key) in (m_c, m_unc)
assert prvkeyinfo_from_prvkey(prv_key, "mainnet") in (m_c, m_unc)
assert prvkeyinfo_from_prvkey(prv_key, "testnet") in (t_c, t_unc)
for invalid_prv_key in [q0, qn, xprv0_dict, xprvn_dict] + invalid_prv_keys:
with pytest.raises(ValueError):
int_from_prvkey(invalid_prv_key)
with pytest.raises(ValueError):
prvkeyinfo_from_prvkey(invalid_prv_key)
for not_a_prv_key in (
[q0, qn, xprv0_dict, xprvn_dict]
+ [INF, INF_xpub_dict]
+ not_a_prv_keys
+ [Q]
+ plain_pub_keys
+ [xpub_dict]
+ compressed_pub_keys
+ uncompressed_pub_keys
):
with pytest.raises(ValueError):
int_from_prvkey(not_a_prv_key)
with pytest.raises(ValueError):
prvkeyinfo_from_prvkey(not_a_prv_key)
def test_address_from_wif(self):
# uncompressed mainnet
wif1 = "5J1geo9kcAUSM6GJJmhYRX1eZEjvos9nFyWwPstVziTVueRJYvW"
pubkey, network = pubkeyinfo_from_prvkey(wif1)
b58 = p2pkh(pubkey)
self.assertEqual(b58, b"1LPM8SZ4RQDMZymUmVSiSSvrDfj1UZY9ig")
self.assertRaises(ValueError, p2wpkh, pubkey)
self.assertRaises(ValueError, p2wpkh_p2sh, pubkey)
# compressed mainnet
wif2 = "Kx621phdUCp6sgEXPSHwhDTrmHeUVrMkm6T95ycJyjyxbDXkr162"
pubkey, network = pubkeyinfo_from_prvkey(wif2)
b58 = p2pkh(pubkey)
self.assertEqual(b58, b"1HJC7kFvXHepkSzdc8RX6khQKkAyntdfkB")
b32 = p2wpkh(pubkey)
self.assertEqual(
h160_from_b58address(b58)[1:],
witness_from_b32address(b32)[1:])
h160 = h160_from_b58address(b58)[1]
b = p2wpkh_p2sh(pubkey)
self.assertEqual(hash160(b"\x00\x14" + h160),
h160_from_b58address(b)[1])
self.assertEqual(
prvkeyinfo_from_prvkey(wif1)[0],
prvkeyinfo_from_prvkey(wif2)[0])
# uncompressed testnet
wif1 = "91gGn1HgSap6CbU12F6z3pJri26xzp7Ay1VW6NHCoEayNXwRpu2"
pubkey, network = pubkeyinfo_from_prvkey(wif1)
b58 = p2pkh(pubkey, network, None)
self.assertEqual(b58, b"mvgbzkCSgKbYgaeG38auUzR7otscEGi8U7")
self.assertRaises(ValueError, p2wpkh, pubkey)
self.assertRaises(ValueError, p2wpkh_p2sh, pubkey)
# compressed testnet
wif2 = "cMzLdeGd5vEqxB8B6VFQoRopQ3sLAAvEzDAoQgvX54xwofSWj1fx"
pubkey, network = pubkeyinfo_from_prvkey(wif2)
b58 = p2pkh(pubkey, network, None)
self.assertEqual(b58, b"n1KSZGmQgB8iSZqv6UVhGkCGUbEdw8Lm3Q")
b32 = p2wpkh(pubkey, network)
self.assertEqual(
h160_from_b58address(b58)[1:],
witness_from_b32address(b32)[1:])
h160 = h160_from_b58address(b58)[1]
b = p2wpkh_p2sh(pubkey, network)
self.assertEqual(hash160(b"\x00\x14" + h160),
h160_from_b58address(b)[1])
self.assertEqual(
prvkeyinfo_from_prvkey(wif1)[0],
prvkeyinfo_from_prvkey(wif2)[0])
# uncompressed mainnet, trailing/leading spaces in string
wif1 = " 5J1geo9kcAUSM6GJJmhYRX1eZEjvos9nFyWwPstVziTVueRJYvW"
pubkey, network = pubkeyinfo_from_prvkey(wif1)
b58 = p2pkh(pubkey)
self.assertEqual(b58, b"1LPM8SZ4RQDMZymUmVSiSSvrDfj1UZY9ig")
self.assertRaises(ValueError, p2wpkh, pubkey)
self.assertRaises(ValueError, p2wpkh_p2sh, pubkey)
# compressed mainnet, trailing/leading spaces in string
wif2 = "Kx621phdUCp6sgEXPSHwhDTrmHeUVrMkm6T95ycJyjyxbDXkr162 "
pubkey, network = pubkeyinfo_from_prvkey(wif2)
b58 = p2pkh(pubkey)
self.assertEqual(b58, b"1HJC7kFvXHepkSzdc8RX6khQKkAyntdfkB")
b32 = p2wpkh(pubkey)
self.assertEqual(
h160_from_b58address(b58)[1:],
witness_from_b32address(b32)[1:])
h160 = h160_from_b58address(b58)[1]
b = p2wpkh_p2sh(pubkey)
self.assertEqual(hash160(b"\x00\x14" + h160),
h160_from_b58address(b)[1])
