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)