def test(self):
for data in priv_pub_hash_addr_p2pkh_segwit:
priv = PrivateKey.from_wif(data['privkey'])
pub = PublicKey.unhexlify(data['pubkey'])
pubhash = bytearray(unhexlify(data['pubkeyhash']))
address = Address.from_string(data['address'], check_network=False)
p2pkhhex = data['scriptpubkey']
segwit_addr = data['segwit']
self.assertEqual(priv.pub(), pub)
self.assertEqual(pub.hash(), pubhash)
self.assertEqual(address.hash, pubhash)
self.assertEqual(P2pkhScript(pub).hexlify(), p2pkhhex)
self.assertEqual(P2pkhScript(address).hexlify(), p2pkhhex)
self.assertEqual(P2pkhScript(pubhash).hexlify(), p2pkhhex)
self.assertEqual(str(P2shScript(P2wpkhV0Script(pub)).address()),
segwit_addr)
self.assertEqual(
str(P2shScript(P2wpkhV0Script(pubhash)).address()),
segwit_addr)
self.assertEqual(
P2shScript(P2wpkhV0Script(pub)).scripthash,
Address.from_string(segwit_addr).hash)
self.assertEqual(
P2shScript(P2wpkhV0Script(pubhash)).scripthash,
Address.from_string(segwit_addr).hash)
def validateaddress(self, address: str) -> bool:
"Returns True if the passed address is valid, False otherwise."
try:
Address.from_string(address, self.network_properties)
except InvalidAddress:
return False
return True
def validateaddress(self, address: str) -> bool:
"Returns True if the passed address is valid, False otherwise."
btcpy_constants = self.network_properties.btcpy_constants
try:
Address.from_string(btcpy_constants, address)
except ValueError:
return False
return True
def test_peercoin_address_failure():
bad_addresses = {
'vioqwV3F4YzpgnfyUukGVMB3Hv83ujehKCiGWyrYyx2Z7hiKQy7SWUV9KgfMdV9J',
'bc1a',
'3rE3tz',
'1KKKK6N21XKo48zWKuQKXdvSsCf95ibHFa',
}
for address in bad_addresses:
with pytest.raises(InvalidAddress):
Address.from_string(address, network=PeercoinMainnet)
def validateaddress(self, address: str) -> bool:
"""Returns True if the passed address is valid, False otherwise. Note
the limitation that we don't check the address against the underlying
network (i.e. strict=False). When btcpy can support multiple networks at
runtime we can be more precise (i.e. strict=True) ;)
"""
try:
Address.from_string(address, strict=False)
except ValueError:
return False
return True
def test_success(self):
for net, addr_type, address, hashed_data in self.good_addresses:
from_string = Address.from_string(address, check_network=False)
self.assertTrue(address == str(from_string))
self.assertTrue(from_string.type == addr_type)
self.assertTrue(from_string.network == net)
self.assertTrue(from_string.hash == hashed_data)
def get_address_hash(
address: str,
script: bool = False) -> Union[str, P2pkhScript, P2shScript]:
"""
Get Bitcoin address hash.
:param address: Bitcoin address.
:type address: str
:param script: Return script (P2pkhScript, P2shScript), default to False.
:type script: bool
:returns: str -- Bitcoin address hash.
>>> from swap.providers.bitcoin.utils import get_address_hash
>>> get_address_hash(address="mrmtGq2HMmqAogSsGDjCtXUpxrb7rHThFH", script=False)
"7b7c4431a43b612a72f8229935c469f1f6903658"
"""
if not is_address(address=address):
raise AddressError(f"Invalid Bitcoin '{address}' address.")
loaded_address = Address.from_string(address)
get_type = loaded_address.get_type()
if not script:
return loaded_address.hash.hex()
if str(get_type) == "p2pkh":
return P2pkhScript(loaded_address)
elif str(get_type) == "p2sh":
return P2shScript(loaded_address)
def test_peercoin_address_success():
good_addresses = {
(
'PeercoinMainnet',
P2pkhAddress,
'PAdonateFczhZuKLkKHozrcyMJW7Y6TKvw',
),
(
'PeercoinTestnet',
P2pkhAddress,
'mj46gUeZgeD9ufU7Fvz2dWqaX6Nswtbpba',
),
(
'PeercoinTestnet',
P2pkhAddress,
'n12h8P5LrVXozfhEQEqg8SFUmVKtphBetj',
),
(
'PeercoinMainnet',
P2shAddress,
'p92W3t7YkKfQEPDb7cG9jQ6iMh7cpKLvwK',
),
}
for net, addr_type, address in good_addresses:
net = PeercoinMainnet if net == 'PeercoinMainnet' else PeercoinTestnet
from_string = Address.from_string(address, network=net)
assert address == str(from_string)
assert from_string.__class__ == addr_type
assert from_string.network == net
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.pubk = PublicKey.unhexlify(
'0384478d41e71dc6c3f9edde0f928a47d1b724c05984ebfb4e7d0422e80abe95ff'
)
self.pubkh = self.pubk.hash()
self.address = Address.from_string(
'mquvJWnJJwTDUcdneQkUbrfN2wm9uiXd1p')
def test_priv_to_pubhash(self):
for priv, addr, _ in privk['derivations']:
self.assertEqual(
str(PrivateKey.from_wif(priv).pub().to_address(mainnet=False)),
addr)
self.assertEqual(
PrivateKey.from_wif(priv).pub().hash(),
Address.from_string(addr, check_network=False).hash)
def p2pkh_script(network: str, address: str) -> P2pkhScript:
'''create pay-to-key-hash (P2PKH) script'''
network_params = net_query(network)
addr = Address.from_string(network=network_params,
string=address)
return P2pkhScript(addr)
def test_conversions(self):
for address, pkh in addresses:
self.assertEqual(
hexlify(
Address.from_string(address,
check_network=False).hash).decode(),
pkh)
self.assertEqual(
str(
P2pkhScript(bytearray(
unhexlify(pkh))).address(mainnet=True)), address)
self.assertEqual(
P2pkhScript(Address.from_string(
address, check_network=False)).pubkeyhash,
bytearray(unhexlify(pkh)))
self.assertEqual(
Address('p2pkh', bytearray(unhexlify(pkh)), mainnet=True).hash,
bytearray(unhexlify(pkh)))
def script_from_address(address, network="testnet"):
if not is_address(address, network):
raise AddressError("invalid %s %s address!" % (network, address))
load_address = Address.from_string(address)
get_type = load_address.get_type()
if str(get_type) == "p2pkh":
return P2pkhScript(load_address)
elif str(get_type) == "p2sh":
return P2shScript(load_address)
def p2sh_p2pkh_script(network: str, address: str) -> P2shScript:
'''p2sh embedding p2pkh'''
network_params = net_query(network)
addr = Address.from_string(network=network_params,
string=address)
p2pkh = P2pkhScript(addr)
return P2shScript(p2pkh)
def test_success_addresses(self):
for script_hex, address in p2sh.items():
script = ScriptBuilder.identify(bytearray(unhexlify(script_hex)))
from_addr = P2shScript(Address.from_string(address))
from_script = P2shScript(script)
self.assertTrue(str(from_addr.address()) == address)
self.assertTrue(str(script.to_address()) == address)
self.assertTrue(str(from_script.address()) == address)
script = P2shScript(self.address)
self.assertTrue(script.decompile() == 'OP_HASH160 {} OP_EQUAL'.format(
self.as_data))
self.assertTrue(script.hexlify() == 'a9{:02x}{}87'.format(
len(self.as_data), self.as_data))
def p2pkh(self) -> str:
"""
Get Bitcoin wallet public key/address p2pkh.
:return: str -- Bitcoin wallet public key/address p2pkh.
>>> from swap.providers.bitcoin.wallet import Wallet
>>> wallet = Wallet(network="testnet")
>>> wallet.from_entropy("72fee73846f2d1a5807dc8c953bf79f1")
>>> wallet.from_path("m/44'/0'/0'/0/0")
>>> wallet.p2pkh()
"76a91433ecab3d67f0e2bde43e52f41ec1ecbdc73f11f888ac"
"""
return P2pkhScript(Address.from_string(self.address())).hexlify()
def from_address(self, address):
"""
Initiate Bitcoin wallet from address.
:param address: Bitcoin wallet private key.
:type address: str.
:returns: Wallet -- Bitcoin wallet instance.
>>> from shuttle.providers.bitcoin.wallet import Wallet
>>> wallet = Wallet(network="testnet")
>>> wallet.from_address("mqLyrNDjpENRMZAoDpspH7kR9RtgvhWzYE")
<shuttle.providers.bitcoin.wallet.Wallet object at 0x040DA268>
"""
if not is_address(address=address, network=self.network):
raise AddressError("invalid %s %s address" %
(self.network, address))
self._address = Address.from_string(address)
return self
def address_to_hash(address, network="testnet"):
"""
Get hash from address.
:param address: Bitcoin address.
:type address: str
:param network: Bitcoin network, defaults to testnet.
:type network: str
:returns: P2pkhScript, P2shScript -- Bitcoin p2pkh or p2sh script instance.
>>> from shuttle.providers.bitcoin.utils import address_to_hash
>>> address_to_hash("mrmtGq2HMmqAogSsGDjCtXUpxrb7rHThFH", "testnet")
"7b7c4431a43b612a72f8229935c469f1f6903658"
"""
if not is_address(address, network):
raise AddressError("invalid %s %s address!" % (network, address))
return Address.from_string(address).hash.hex()
def get_address_type(address: str) -> str:
"""
Get Bitcoin address type.
:param address: Bitcoin address.
:type address: str
:returns: str -- Bitcoin address type (P2PKH, P2SH).
>>> from swap.providers.bitcoin.utils import get_address_type
>>> get_address_type(address="mrmtGq2HMmqAogSsGDjCtXUpxrb7rHThFH")
"p2pkh"
"""
if not is_address(address=address):
raise AddressError(f"Invalid Bitcoin '{address}' address.")
loaded_address = Address.from_string(address)
address_type = loaded_address.get_type()
return str(address_type)
def p2pkh(self, address=None):
"""
Get Bitcoin wallet p2pkh.
:param address: Bitcoin p2pkh, default is None.
:type address: str
:return: str -- Bitcoin p2pkh.
>>> from shuttle.providers.bitcoin.wallet import Wallet
>>> wallet = Wallet(network="testnet")
>>> wallet.from_passphrase("meherett")
>>> wallet.p2pkh()
"76a9143c8acde1c7cf370d970725f13eff03bf74b3fc6188ac"
"""
if address is None:
return P2pkhScript(self._address).hexlify()
if not is_address(address=address, network=self.network):
raise AddressError("invalid %s %s address" %
(self.network, address))
address = Address.from_string(address)
return P2pkhScript(address).hexlify()
def p2sh(self, address=None):
"""
Get Bitcoin wallet p2sh.
:param address: Bitcoin p2sh, default is None.
:type address: str
:return: str -- Bitcoin p2sh.
>>> from shuttle.providers.bitcoin.wallet import Wallet
>>> wallet = Wallet(network="testnet")
>>> wallet.from_passphrase("meherett")
>>> wallet.p2sh()
"a914a3c4995d9cd0303e5f89ee1433212c797d04ee5d87"
"""
if address is None:
return P2shScript(P2pkhScript(self._address)).hexlify()
if not is_address(address=address, network=self.network):
raise AddressError("invalid %s %s address" %
(self.network, address))
address = Address.from_string(address)
return P2shScript(P2pkhScript(address)).hexlify()
def script_from_address(address, network="testnet"):
"""
Get script from address.
:param address: Bitcoin address.
:type address: str
:param network: Bitcoin network, defaults to testnet.
:type network: str
:returns: P2pkhScript, P2shScript -- Bitcoin p2pkh or p2sh script instance.
>>> from shuttle.providers.bitcoin.utils import script_from_address
>>> script_from_address("mrmtGq2HMmqAogSsGDjCtXUpxrb7rHThFH", "testnet")
P2pkhScript('7b7c4431a43b612a72f8229935c469f1f6903658')
"""
if not is_address(address, network):
raise AddressError("invalid %s %s address!" % (network, address))
load_address = Address.from_string(address)
get_type = load_address.get_type()
if str(get_type) == "p2pkh":
return P2pkhScript(load_address)
elif str(get_type) == "p2sh":
return P2shScript(load_address)
def p2pkh_script(address: str) -> P2pkhScript:
'''create pay-to-key-hash (P2PKH) script'''
addr = Address.from_string(address)
return P2pkhScript(addr)
def test_fail(self):
for address in self.bad_addresses:
with self.assertRaises(ValueError):
Address.from_string(address, check_network=False)